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

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

@@ -6,47 +6,67 @@
  */
 
 import type { ReactNode } from "react";
-import { DataNotFoundError, invariant } from "../../errors";
-import {
-  createErrorInfo,
-  createErrorSegment,
-  createNotFoundInfo,
-  createNotFoundSegment,
-} from "../error-handling.js";
-import { getRequestContext } from "../../server/request-context.js";
-import { DefaultErrorFallback } from "../../default-error-boundary.js";
+import { invariant } from "../../errors";
 import type { EntryData } from "../../server/context";
 import type {
   HandlerContext,
   InternalHandlerContext,
   ResolvedSegment,
-  ErrorInfo,
 } from "../../types";
 import type { SegmentResolutionDeps } from "../types.js";
-import { debugLog } from "../logging.js";
-import { tryStaticLookup } from "./static-store.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";
+
+// ---------------------------------------------------------------------------
+// Streamed handler telemetry
+// ---------------------------------------------------------------------------
 
 /**
- * Handle Response returns from handlers.
- * When a handler returns a Response (e.g., redirect), throw it to trigger
- * the short-circuit mechanism. Otherwise return the ReactNode.
+ * Attach a fire-and-forget rejection observer to a streamed handler promise.
+ * React catches the actual error via its error boundary; this only emits
+ * the handler.error telemetry event.
  */
-export function handleHandlerResult(
-  result: ReactNode | Response | Promise<ReactNode> | Promise<Response>,
-): ReactNode {
-  if (result instanceof Response) {
-    throw result;
-  }
-  if (result instanceof Promise) {
-    return result.then((resolved) => {
-      if (resolved instanceof Response) {
-        throw resolved;
-      }
-      return resolved;
-    }) as ReactNode;
+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;
   }
-  return result;
+  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,
+    });
+  });
 }
 
 // ---------------------------------------------------------------------------
@@ -154,38 +174,14 @@ export async function resolveSegment<TEnv>(
       segments.push(...loaderSegments);
     }
 
-    for (const parallelEntry of entry.parallel) {
-      const parallelSegments = await resolveParallelEntry(
-        parallelEntry,
-        params,
-        context,
-        false,
-        entry.shortCode,
-        deps,
-        options,
-      );
-      segments.push(...parallelSegments);
-    }
-
+    // Handler-first: layout handler executes before its parallels and orphan
+    // layouts so that ctx.set() values are visible to all children.
     (context as InternalHandlerContext<any, TEnv>)._currentSegmentId =
       entry.shortCode;
 
-    // Static handler interception: use pre-rendered component from build-time store.
-    // Cast via any because the cache entry type in the union lacks isStaticPrerender.
-    const entryAny = entry as any;
-    let component: ReactNode | undefined;
-    if (entryAny.isStaticPrerender && entryAny.staticHandlerId) {
-      component = await tryStaticLookup(
-        entryAny.staticHandlerId,
-        entry.shortCode,
-      );
-    }
-    if (component === undefined) {
-      component =
-        typeof entry.handler === "function"
-          ? handleHandlerResult(await entry.handler(context))
-          : entry.handler;
-    }
+    const doneLayoutHandler = track(`handler:${entry.id}`, 2);
+    const component = await resolveLayoutComponent(entry, context);
+    doneLayoutHandler();
 
     segments.push({
       id: entry.shortCode,
@@ -201,6 +197,20 @@ export async function resolveSegment<TEnv>(
       ...(entry.mountPath ? { mountPath: entry.mountPath } : {}),
     });
 
+    for (const parallelEntry of entry.parallel) {
+      const parallelSegments = await resolveParallelEntry(
+        parallelEntry,
+        params,
+        context,
+        false,
+        entry.shortCode,
+        deps,
+        options,
+        routeKey,
+      );
+      segments.push(...parallelSegments);
+    }
+
     for (const orphan of entry.layout) {
       const orphanSegments = await resolveOrphanLayout(
         orphan,
@@ -210,6 +220,7 @@ export async function resolveSegment<TEnv>(
         false,
         deps,
         options,
+        routeKey,
       );
       segments.push(...orphanSegments);
     }
@@ -228,22 +239,36 @@ export async function resolveSegment<TEnv>(
     // the correct tree composition order (layouts wrap the route content).
     (context as InternalHandlerContext<any, TEnv>)._currentSegmentId =
       entry.shortCode;
-    let component: ReactNode | undefined;
-
-    // Static handler interception: use pre-rendered component from build-time store
-    if (entry.isStaticPrerender && (entry as any).staticHandlerId) {
-      component = await tryStaticLookup(
-        (entry as any).staticHandlerId,
-        entry.shortCode,
-      );
-    }
+    let component: ReactNode | undefined = await tryStaticHandler(
+      entry,
+      entry.shortCode,
+    );
     if (component === undefined) {
+      const doneRouteHandler = track(`handler:${entry.id}`, 2);
       if (entry.loading) {
         const result = handleHandlerResult(entry.handler(context));
-        component =
-          result instanceof Promise ? deps.trackHandler(result) : result;
+        if (result instanceof Promise) {
+          result.finally(doneRouteHandler).catch(() => {});
+          const tracked = deps.trackHandler(result, {
+            segmentId: entry.shortCode,
+            segmentType: entry.type,
+          });
+          observeStreamedHandler(
+            tracked,
+            entry.shortCode,
+            entry.type,
+            context.pathname,
+            routeKey,
+            params,
+          );
+          component = tracked;
+        } else {
+          doneRouteHandler();
+          component = result;
+        }
       } else {
         component = handleHandlerResult(await entry.handler(context));
+        doneRouteHandler();
       }
     }
 
@@ -256,6 +281,7 @@ export async function resolveSegment<TEnv>(
         true,
         deps,
         options,
+        routeKey,
       );
       segments.push(...orphanSegments);
     }
@@ -269,6 +295,7 @@ export async function resolveSegment<TEnv>(
         entry.shortCode,
         deps,
         options,
+        routeKey,
       );
       segments.push(...parallelSegments);
     }
@@ -303,6 +330,7 @@ export async function resolveOrphanLayout<TEnv>(
   belongsToRoute: boolean,
   deps: SegmentResolutionDeps<TEnv>,
   options?: ResolveSegmentOptions,
+  routeKey?: string,
 ): Promise<ResolvedSegment[]> {
   invariant(
     orphan.type === "layout" || orphan.type === "cache",
@@ -320,34 +348,11 @@ export async function resolveOrphanLayout<TEnv>(
     segments.push(...loaderSegments);
   }
 
-  for (const parallelEntry of orphan.parallel) {
-    const parallelSegments = await resolveParallelEntry(
-      parallelEntry,
-      params,
-      context,
-      belongsToRoute,
-      orphan.shortCode,
-      deps,
-      options,
-    );
-    segments.push(...parallelSegments);
-  }
-
-  // Static handler interception for orphan layouts
-  const orphanAny = orphan as any;
-  let component: ReactNode | undefined;
-  if (orphanAny.isStaticPrerender && orphanAny.staticHandlerId) {
-    component = await tryStaticLookup(
-      orphanAny.staticHandlerId,
-      orphan.shortCode,
-    );
-  }
-  if (component === undefined) {
-    component =
-      typeof orphan.handler === "function"
-        ? handleHandlerResult(await orphan.handler(context))
-        : orphan.handler;
-  }
+  // Handler-first: orphan layout handler executes before its parallels
+  // so that ctx.set() values are visible to parallel children.
+  const doneOrphanHandler = track(`handler:${orphan.id}`, 2);
+  const component = await resolveLayoutComponent(orphan, context);
+  doneOrphanHandler();
 
   segments.push({
     id: orphan.shortCode,
@@ -363,6 +368,20 @@ export async function resolveOrphanLayout<TEnv>(
     ...(orphan.mountPath ? { mountPath: orphan.mountPath } : {}),
   });
 
+  for (const parallelEntry of orphan.parallel) {
+    const parallelSegments = await resolveParallelEntry(
+      parallelEntry,
+      params,
+      context,
+      belongsToRoute,
+      orphan.shortCode,
+      deps,
+      options,
+      routeKey,
+    );
+    segments.push(...parallelSegments);
+  }
+
   return segments;
 }
 
@@ -377,6 +396,7 @@ export async function resolveParallelEntry<TEnv>(
   parentShortCode: string,
   deps: SegmentResolutionDeps<TEnv>,
   options?: ResolveSegmentOptions,
+  routeKey?: string,
 ): Promise<ResolvedSegment[]> {
   invariant(
     parallelEntry.type === "parallel",
@@ -392,27 +412,45 @@ export async function resolveParallelEntry<TEnv>(
   >;
 
   for (const [slot, handler] of Object.entries(slots)) {
-    let component: ReactNode | undefined;
-
-    // Static handler interception for individual parallel slots
-    const slotStaticId = (parallelEntry as any).staticHandlerIds?.[slot];
-    if (slotStaticId) {
-      component = await tryStaticLookup(
-        slotStaticId,
-        `${parentShortCode}.${slot}`,
-      );
-    }
+    let component: ReactNode | undefined = await tryStaticSlot(
+      parallelEntry,
+      slot,
+      `${parentShortCode}.${slot}`,
+    );
 
     if (component === undefined) {
+      const doneParallelHandler = track(
+        `handler:${parallelEntry.id}.${slot}`,
+        2,
+      );
       const hasLoadingFallback =
         parallelEntry.loading !== undefined && parallelEntry.loading !== false;
       if (hasLoadingFallback) {
         const result =
           typeof handler === "function" ? handler(context) : handler;
-        component = result as ReactNode;
+        if (result instanceof Promise) {
+          result.finally(doneParallelHandler).catch(() => {});
+          const tracked = deps.trackHandler(result, {
+            segmentId: `${parentShortCode}.${slot}`,
+            segmentType: "parallel",
+          });
+          observeStreamedHandler(
+            tracked,
+            `${parentShortCode}.${slot}`,
+            "parallel",
+            context.pathname,
+            routeKey,
+            params,
+          );
+          component = tracked as ReactNode;
+        } else {
+          doneParallelHandler();
+          component = result as ReactNode;
+        }
       } else {
         component =
           typeof handler === "function" ? await handler(context) : handler;
+        doneParallelHandler();
       }
     }
 
@@ -448,136 +486,6 @@ export async function resolveParallelEntry<TEnv>(
   return segments;
 }
 
-/**
- * Wrapper that adds error boundary handling to segment resolution.
- */
-export async function resolveWithErrorHandling<TEnv>(
-  entry: EntryData,
-  routeKey: string,
-  params: Record<string, string>,
-  context: HandlerContext<any, TEnv>,
-  loaderPromises: Map<string, Promise<any>>,
-  resolveFn: () => Promise<ResolvedSegment[]>,
-  deps: SegmentResolutionDeps<TEnv>,
-  errorContext?: {
-    env?: TEnv;
-    isPartial?: boolean;
-    requestStartTime?: number;
-  },
-): Promise<ResolvedSegment[]> {
-  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,
-          context.pathname,
-        );
-
-        // Safe request access: during build-time prerendering, context.request
-        // is a throwing getter. Use undefined when unavailable.
-        let safeRequest: Request | undefined;
-        try {
-          safeRequest = context.request;
-        } catch {}
-
-        deps.callOnError(error, "handler", {
-          request: safeRequest as Request,
-          url: context.url,
-          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 [notFoundSegment];
-      }
-    }
-
-    const fallback = deps.findNearestErrorBoundary(entry);
-    const segmentType: ErrorInfo["segmentType"] = entry.type;
-    const errorInfo = createErrorInfo(error, entry.shortCode, segmentType);
-    const effectiveFallback = fallback ?? DefaultErrorFallback;
-
-    // Safe request access: during build-time prerendering, context.request
-    // is a throwing getter. Use undefined when unavailable.
-    let safeReq: Request | undefined;
-    try {
-      safeReq = context.request;
-    } catch {}
-
-    deps.callOnError(error, "handler", {
-      request: safeReq as Request,
-      url: context.url,
-      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 [errorSegment];
-  }
-}
-
 /**
  * Resolve all segments for a route (used for single-cache-per-request pattern).
  */
@@ -593,13 +501,24 @@ export async function resolveAllSegments<TEnv>(
   const allSegments: ResolvedSegment[] = [];
   const seenIds = new Set<string>();
 
+  // Safe request access: during build-time prerendering, context.request
+  // is a throwing getter. Use undefined when unavailable.
+  let safeRequest: Request | undefined;
+  try {
+    safeRequest = context.request;
+  } catch {}
+
+  // Get telemetry sink from RouterContext (may not exist during prerendering)
+  let telemetry;
+  try {
+    telemetry = getRouterContext()?.telemetry;
+  } catch {}
+
   for (const entry of entries) {
-    const resolvedSegments = await resolveWithErrorHandling(
+    const doneEntry = track(`segment:${entry.id}`, 1);
+    const resolvedSegments = await resolveWithErrorBoundary(
       entry,
-      routeKey,
       params,
-      context,
-      loaderPromises,
       () =>
         resolveSegment(
           entry,
@@ -611,8 +530,12 @@ export async function resolveAllSegments<TEnv>(
           false,
           options,
         ),
+      (seg) => [seg],
       deps,
+      { request: safeRequest, url: context.url, routeKey, telemetry },
+      context.pathname,
     );
+    doneEntry();
     // Deduplicate by segment ID. include() scopes can produce entries that
     // resolve the same shared layout/loader segment. Duplicates in the segment
     // array propagate to the client's matched[] and change the React tree depth.