fix

Author: schiller-manuel

packages/router-core/src/load-matches.ts

@@ -81,7 +81,7 @@ const getNotFoundBoundaryIndex = (
     return undefined
   }
 
-  const requestedRouteId = err.routeId ? String(err.routeId) : undefined
+  const requestedRouteId = err.routeId
   const matchedRootIndex = inner.matches.findIndex(
     (m) => m.routeId === inner.router.routeTree.id,
   )
@@ -890,7 +890,7 @@ export async function loadMatches(arg: {
   updateMatch: UpdateMatchFn
   sync?: boolean
 }): Promise<Array<MakeRouteMatch>> {
-  const inner: InnerLoadContext = Object.assign(arg)
+  const inner: InnerLoadContext = arg
   const matchPromises: Array<Promise<AnyRouteMatch>> = []
 
   // make sure the pending component is immediately rendered when hydrating a match that is not SSRed
@@ -941,7 +941,6 @@ export async function loadMatches(arg: {
         ? Math.min(boundaryIndex + 1, baseMaxIndexExclusive)
         : baseMaxIndexExclusive
 
-  let firstRedirect: unknown
   let firstNotFound: NotFoundError | undefined
 
   for (let i = 0; i < maxIndexExclusive; i++) {
@@ -957,19 +956,15 @@ export async function loadMatches(arg: {
       if (result.status !== 'rejected') continue
 
       const reason = result.reason
-      if (!firstRedirect && isRedirect(reason)) {
-        firstRedirect = reason
+      if (isRedirect(reason)) {
+        throw reason
       }
       if (!firstNotFound && isNotFound(reason)) {
         firstNotFound = reason
       }
     }
   }
 
-  if (firstRedirect) {
-    throw firstRedirect
-  }
-
   const notFoundToThrow =
     firstNotFound ??
     (beforeLoadNotFound && !inner.preload ? beforeLoadNotFound : undefined)
@@ -1008,10 +1003,19 @@ export async function loadMatches(arg: {
 
     notFoundToThrow.routeId = boundaryMatch.routeId
 
+    const boundaryIsRoot = boundaryMatch.routeId === inner.router.routeTree.id
+
     inner.updateMatch(boundaryMatch.id, (prev) => ({
       ...prev,
-      status: 'notFound',
-      error: notFoundToThrow,
+      ...(boundaryIsRoot
+        ? // For root boundary, use globalNotFound so the root component's
+          // shell still renders and <Outlet> handles the not-found display.
+          // Setting status:'notFound' on root would replace the entire shell,
+          // and in Solid/Vue the status update can be lost inside startTransition.
+          { globalNotFound: true }
+        : // For non-root boundaries, set status:'notFound' so MatchInner
+          // renders the notFoundComponent directly.
+          { status: 'notFound' as const, error: notFoundToThrow }),
       isFetching: false,
     }))
 

packages/router-core/src/ssr/ssr-client.ts

@@ -28,6 +28,9 @@ function hydrateMatch(
   match.ssr = deyhydratedMatch.ssr
   match.updatedAt = deyhydratedMatch.u
   match.error = deyhydratedMatch.e
+  if (deyhydratedMatch.g !== undefined) {
+    match.globalNotFound = true
+  }
 }
 
 export async function hydrate(router: AnyRouter): Promise<any> {

packages/router-core/src/ssr/ssr-server.ts

@@ -47,6 +47,7 @@ export function dehydrateMatch(match: AnyRouteMatch): DehydratedMatch {
     ['loaderData', 'l'],
     ['error', 'e'],
     ['ssr', 'ssr'],
+    ['globalNotFound', 'g'],
   ] as const
 
   for (const [key, shorthand] of properties) {

packages/router-core/src/ssr/types.ts

@@ -9,6 +9,7 @@ export interface DehydratedMatch {
   u: MakeRouteMatch['updatedAt']
   s: MakeRouteMatch['status']
   ssr?: MakeRouteMatch['ssr']
+  g?: true
 }
 
 export interface DehydratedRouter {

packages/router-core/tests/hydrate.test.ts

@@ -218,6 +218,93 @@ describe('hydrate', () => {
     expect(ssr).toBe(true)
   })
 
+  it('should hydrate globalNotFound when dehydrated flag is present', async () => {
+    const mockMatches = [
+      {
+        id: '/',
+        routeId: '/',
+        index: 0,
+        ssr: undefined,
+        _nonReactive: {},
+      },
+    ]
+
+    const dehydratedMatches = [
+      {
+        i: '/',
+        s: 'success' as const,
+        ssr: true,
+        u: Date.now(),
+        g: true as const,
+      },
+    ]
+
+    mockRouter.matchRoutes = vi.fn().mockReturnValue(mockMatches)
+    mockRouter.state.matches = mockMatches
+
+    mockWindow.$_TSR = {
+      router: {
+        manifest: { routes: {} },
+        dehydratedData: {},
+        lastMatchId: '/',
+        matches: dehydratedMatches,
+      },
+      h: vi.fn(),
+      e: vi.fn(),
+      c: vi.fn(),
+      p: vi.fn(),
+      buffer: [],
+      initialized: false,
+    }
+
+    await hydrate(mockRouter)
+
+    expect((mockMatches[0] as AnyRouteMatch).globalNotFound).toBe(true)
+  })
+
+  it('should leave globalNotFound undefined when dehydrated flag is omitted', async () => {
+    const mockMatches = [
+      {
+        id: '/',
+        routeId: '/',
+        index: 0,
+        ssr: undefined,
+        _nonReactive: {},
+      },
+    ]
+
+    const dehydratedMatches = [
+      {
+        i: '/',
+        s: 'success' as const,
+        ssr: true,
+        u: Date.now(),
+      },
+    ]
+
+    mockRouter.matchRoutes = vi.fn().mockReturnValue(mockMatches)
+    mockRouter.state.matches = mockMatches
+
+    mockWindow.$_TSR = {
+      router: {
+        manifest: { routes: {} },
+        dehydratedData: {},
+        lastMatchId: '/',
+        matches: dehydratedMatches,
+      },
+      h: vi.fn(),
+      e: vi.fn(),
+      c: vi.fn(),
+      p: vi.fn(),
+      buffer: [],
+      initialized: false,
+    }
+
+    await hydrate(mockRouter)
+
+    expect((mockMatches[0] as AnyRouteMatch).globalNotFound).toBeUndefined()
+  })
+
   it('should decode dehydrated match ids before hydration lookup and SPA-mode checks', async () => {
     const loadSpy = vi.spyOn(mockRouter, 'load')