@tanstack/router-core 1.171.16-pre.0 → 1.171.16

package/src/load-client.ts

@@ -2,12 +2,7 @@
 // can rewrite relative imports for both ESM and CJS.
 import { isNotFound } from './not-found'
 import { isRedirect } from './redirect'
-import {
-  _getUserHistoryState,
-  getLocationChangeInfo,
-  runRouteLifecycle,
-} from './router'
-import { deepEqual } from './utils'
+import { getLocationChangeInfo, runRouteLifecycle } from './router'
 import { hydrateSsrMatchId } from './ssr/ssr-match-id'
 import type { GLOBAL_SEROVAL, GLOBAL_TSR } from './ssr/constants'
 import type { AnySerializationAdapter } from './ssr/serializer/transformer'
@@ -46,26 +41,35 @@ function preloadComponent(
   return (route.options[type] as any)?.preload?.()
 }
 
-function loadComponents(route: AnyRoute): Promise<void> | undefined {
+function loadComponents(
+  route: AnyRoute,
+  onPendingReady?: () => void,
+): Promise<void> | undefined {
   const component = preloadComponent(route, 'component')
   const pending = preloadComponent(route, 'pendingComponent')
-  if (component && pending) {
-    return Promise.all([component, pending]).then(() => {})
+  const pendingReady =
+    onPendingReady && pending ? pending.then(onPendingReady) : pending
+  if (onPendingReady && !pending) {
+    onPendingReady()
   }
-  return component ?? pending
+  if (component && pendingReady) {
+    return Promise.all([component, pendingReady]).then(() => {})
+  }
+  return component ?? pendingReady
 }
 
 export function loadRouteChunk(
   route: AnyRoute,
   // `false` waits only for lazy route options, before a boundary is selected.
   componentType?: 'errorComponent' | 'notFoundComponent' | false,
+  onPendingReady?: () => void,
 ): Promise<void> | undefined {
   const afterLazy = () =>
     componentType === false
       ? undefined
       : componentType
         ? preloadComponent(route, componentType)
-        : loadComponents(route)
+        : loadComponents(route, onPendingReady)
   const current = route._lazy
   if (current) {
     return current === true ? afterLazy() : current.then(afterLazy)
@@ -161,11 +165,11 @@ const REDIRECTED = 3
 const CANCELED = 4
 
 type LoaderOutcome =
-  | [typeof SUCCESS, data: unknown]
-  | [typeof ERROR, error: unknown]
-  | [typeof NOT_FOUND, error: NotFoundError]
-  | [typeof REDIRECTED, redirect: AnyRedirect]
-  | [typeof CANCELED]
+  | [kind: typeof SUCCESS, data: unknown]
+  | [kind: typeof ERROR, error: unknown]
+  | [kind: typeof NOT_FOUND, error: NotFoundError]
+  | [kind: typeof REDIRECTED, redirect: AnyRedirect]
+  | [kind: typeof CANCELED]
 
 type IndexedOutcome = [index: number, outcome: LoaderOutcome, boundary?: number]
 
@@ -190,31 +194,6 @@ declare const matchPhase: unique symbol
  */
 type SettledMatch = WorkMatch & { readonly [matchPhase]: 'settled' }
 
-export type LaneInputs = [
-  routeTree: AnyRoute,
-  context: unknown,
-  additionalContext: unknown,
-  state: object,
-  search: object,
-  maskedLocation:
-    | [
-        href: string,
-        state: object,
-        search: object,
-        unmaskOnReload: boolean | undefined,
-      ]
-    | undefined,
-]
-
-export type ActivePreload = [
-  matches: Array<AnyRouteMatch>,
-  controller: AbortController,
-  result: Promise<LaneResult>,
-  semanticOwner: Array<AnyRouteMatch>,
-  inputs: LaneInputs,
-  redirects: number,
-]
-
 export type LoadTransaction = [
   controller: AbortController,
   redirects: number,
@@ -224,12 +203,14 @@ export type LoadTransaction = [
   done: Promise<void>,
   /**
    * Dev-only HMR refresh mode. Presence is the mode flag; a refresh always
-   * carries the presentation it started from, while the hydration handoff is
-   * genuinely optional — the tuple makes a half-armed refresh unrepresentable.
+   * carries the presentation it started from and its optional hydration
+   * handoff. While a publication awaits acknowledgement, its rollback lives
+   * with the transaction that owns the publication.
    */
   refresh?: [
     presentation: Array<AnyRouteMatch>,
     handoff: NonNullable<AnyRouter['_handoff']> | undefined,
+    rollback?: () => boolean,
   ],
 ]
 
@@ -244,10 +225,9 @@ export type PendingSession = [
 ]
 
 type CoordinatorRouter = AnyRouter & {
-  /** Whole speculative lanes that a matching navigation may adopt. */
-  _preloads?: Map<string, ActivePreload>
+  /** Active speculative lanes retained for cancellation, invalidation, and cache clearing. */
+  _preloads?: Map<AbortController, Array<AnyRouteMatch>>
   _refreshNextLoad?: boolean
-  _rollbackRefresh?: () => void
   _cancelTransition?: () => void
 }
 
@@ -262,14 +242,14 @@ type PublicationCheckpoint = {
 type LoaderTask = [
   index: number,
   outcome: Promise<LoaderOutcome>,
-  ready: Promise<IndexedOutcome | undefined>,
+  chunkFailure: Promise<IndexedOutcome | undefined>,
   candidate?: WorkMatch,
 ]
 
 type BackgroundLoaderTask = [
   index: number,
   outcome: Promise<LoaderOutcome>,
-  ready: Promise<IndexedOutcome | undefined>,
+  chunkFailure: Promise<IndexedOutcome | undefined>,
   candidate: WorkMatch,
 ]
 
@@ -286,15 +266,15 @@ type ExecuteLaneOptions = [
 ]
 
 type ControlOutcome =
-  | [typeof REDIRECTED, redirect: AnyRedirect]
-  | [typeof CANCELED]
+  | [kind: typeof REDIRECTED, redirect: AnyRedirect]
+  | [kind: typeof CANCELED]
 
 type LaneResult = ProjectedLane | ControlOutcome
 
 function isControl(
   result: Lane<any> | ControlOutcome,
 ): result is ControlOutcome {
-  return typeof result[0] === 'number'
+  return typeof result[0 /* location or kind */] === 'number'
 }
 
 export function waitFor<T>(
@@ -337,11 +317,11 @@ function normalize(
 
 function normalizeError(route: AnyRoute, cause: unknown): LoaderOutcome {
   let outcome = normalize(cause, true, route.id)
-  if (outcome[0] !== ERROR) {
+  if (outcome[0 /* kind */] !== ERROR) {
     return outcome
   }
   try {
-    route.options.onError?.(outcome[1])
+    route.options.onError?.(outcome[1 /* error */])
   } catch (onErrorCause) {
     outcome = normalize(onErrorCause, true, route.id)
   }
@@ -353,8 +333,11 @@ function normalizeLaneError(
   cause: unknown,
   options: ExecuteLaneOptions,
 ): LoaderOutcome {
-  if (options[0].signal.aborted || !options[2]()) {
-    options[0].abort()
+  if (
+    options[0 /* controller */].signal.aborted ||
+    !options[2 /* isCurrent */]()
+  ) {
+    options[0 /* controller */].abort()
     return [CANCELED]
   }
   return normalizeError(route, cause)
@@ -373,15 +356,16 @@ async function contextualize(
   lane: MatchedLane,
   options: ExecuteLaneOptions,
   end: number,
+  planSuccessfulLane: () => void,
 ): Promise<IndexedOutcome | undefined> {
   const [location, matches] = lane
-  const signal = options[0].signal
-  const preload = !!options[4]
-  for (let index = options[7] ?? 0; index < end; index++) {
+  const signal = options[0 /* controller */].signal
+  const preload = !!options[4 /* preload */]
+  for (let index = options[7 /* resolvedPrefix */] ?? 0; index < end; index++) {
     const match = matches[index]!
     const route = getRoute(router, match)
 
-    match.abortController = options[0]
+    match.abortController = options[0 /* controller */]
     // Contextualization is serial, so the previous match already contains the
     // complete parent context for this route.
     const parentContext =
@@ -392,7 +376,7 @@ async function contextualize(
       navigate: navigateFrom(router, location),
       buildLocation: router.buildLocation,
       cause: preload ? ('preload' as const) : match.cause,
-      abortController: options[0],
+      abortController: options[0 /* controller */],
       preload,
       matches,
       routeId: route.id,
@@ -417,8 +401,8 @@ async function contextualize(
       releaseFlight(router, match)
       return [index, normalizeLaneError(route, cause, options)]
     }
-    if (signal.aborted || !options[2]()) {
-      options[0].abort()
+    if (signal.aborted || !options[2 /* isCurrent */]()) {
+      options[0 /* controller */].abort()
       return [index, [CANCELED]]
     }
     const validationError = match.paramsError ?? match.searchError
@@ -452,16 +436,16 @@ async function contextualize(
     if (previousStatus === 'success') {
       match.status = 'pending'
     }
-    options[8]?.()
+    options[8 /* onReady */]?.()
     try {
-      setFetching(router, match, 'beforeLoad', options[0])
+      setFetching(router, match, 'beforeLoad', options[0 /* controller */])
       const result = await waitFor(beforeLoad(beforeLoadContext), signal)
-      if (!options[2]()) {
-        options[0].abort()
+      if (!options[2 /* isCurrent */]()) {
+        options[0 /* controller */].abort()
         return [index, [CANCELED]]
       }
       const outcome = normalize(result, false, route.id)
-      if (outcome[0] !== SUCCESS) {
+      if (outcome[0 /* kind */] !== SUCCESS) {
         releaseFlight(router, match)
         return [index, outcome]
       }
@@ -476,73 +460,54 @@ async function contextualize(
       if (previousStatus === 'success' && match.status === 'pending') {
         match.status = 'success'
       }
-      setFetching(router, match, false, options[0])
+      setFetching(router, match, false, options[0 /* controller */])
     }
   }
 
+  // Let a synchronous lane claim predecessor flights before this frame yields.
+  planSuccessfulLane()
   return
 }
 
 function releaseOwnedFlight(
   router: AnyRouter,
-  id: string,
+  match: WorkMatch,
   flight?: LoaderFlight,
 ): AbortController | undefined {
-  if (!flight || --flight[2]) {
+  if (!flight || --flight[2 /* leases */]) {
     return
   }
-  if (router._flights?.get(id) === flight) {
-    router._flights.delete(id)
+  if (router._flights?.get(match.id) === flight) {
+    const current = router._tx
+    if (
+      current &&
+      !current[0 /* controller */].signal.aborted &&
+      !(process.env.NODE_ENV !== 'production' && current[6 /* refresh */]) &&
+      !current[3 /* matches */].includes(match) &&
+      current[3 /* matches */].some((candidate) => candidate.id === match.id) &&
+      current[3 /* matches */].some(
+        (candidate) => candidate.isFetching === 'beforeLoad',
+      )
+    ) {
+      // Keep work discoverable only while the current lane is still running
+      // beforeLoad. Loader planning performs the matching zero-owner sweep.
+      return
+    }
+    router._flights.delete(match.id)
   }
-  return flight[1]
+  return flight[1 /* controller */]
 }
 
 function releaseFlight(router: AnyRouter, match: WorkMatch): void {
   const flight = match._flight
   match._flight = undefined
-  releaseOwnedFlight(router, match.id, flight)?.abort()
-}
-export function laneInputs(
-  router: AnyRouter,
-  location: ParsedLocation,
-): LaneInputs {
-  const masked = location.maskedLocation
-  return [
-    router.routeTree,
-    router.options.context ?? {},
-    router.options.additionalContext,
-    _getUserHistoryState(location.state),
-    location.search,
-    masked && [
-      masked.href,
-      _getUserHistoryState(masked.state),
-      masked.search,
-      masked.unmaskOnReload,
-    ],
-  ]
-}
-
-function samePreloadLane(
-  preload: ActivePreload,
-  router: AnyRouter,
-  location: ParsedLocation,
-  redirects: number,
-): boolean {
-  return (
-    preload[3] === router._committed &&
-    preload[5] === redirects &&
-    deepEqual(preload[4], laneInputs(router, location)) &&
-    !preload[0].some(
-      (match) => getRoute(router, match as WorkMatch).options.preload === false,
-    )
-  )
+  releaseOwnedFlight(router, match, flight)?.abort()
 }
-
 /**
  * Not passing in a `next` ownership recipient
  * is equivalent to discarding the match resources
  */
-export function transferMatchResources(
+function transferMatchResources(
   router: AnyRouter,
   previous: Array<AnyRouteMatch>,
   next?: Array<AnyRouteMatch>,
@@ -552,7 +517,7 @@ export function transferMatchResources(
     if (!next?.includes(match)) {
       const flight = match._flight
       match._flight = undefined
-      const controller = releaseOwnedFlight(router, match.id, flight)
+      const controller = releaseOwnedFlight(router, match, flight)
       if (controller) {
         abort.push(controller)
       }
@@ -563,16 +528,57 @@ export function transferMatchResources(
   }
 }
 
-function discardPreload(router: AnyRouter, preload: ActivePreload): void {
-  preload[1].abort()
-  transferMatchResources(router, preload[0])
+function transferPredecessorResources(
+  router: AnyRouter,
+  previous: Array<AnyRouteMatch>,
+  next: Array<AnyRouteMatch>,
+): void {
+  const abort: Array<AbortController> = []
+  for (const match of previous as Array<WorkMatch>) {
+    if (!next.includes(match)) {
+      const flight = match._flight
+      match._flight = undefined
+      if (
+        flight?.[2 /* leases */] === 1 &&
+        router._flights?.get(match.id) === flight &&
+        !(
+          process.env.NODE_ENV !== 'production' && router._tx?.[6 /* refresh */]
+        ) &&
+        next.some((candidate) => candidate.id === match.id)
+      ) {
+        // The successor has not made its same-ID reload decision yet.
+        flight[2 /* leases */] = 0
+      } else {
+        const controller = releaseOwnedFlight(router, match, flight)
+        if (controller) {
+          abort.push(controller)
+        }
+      }
+    }
+  }
+  for (const controller of abort) {
+    controller.abort()
+  }
+}
+
+function releaseUnownedFlights(router: AnyRouter): void {
+  const abort: Array<AbortController> = []
+  for (const [id, flight] of router._flights ?? []) {
+    if (!flight[2 /* leases */]) {
+      router._flights!.delete(id)
+      abort.push(flight[1 /* controller */])
+    }
+  }
+  for (const controller of abort) {
+    controller.abort()
+  }
 }
 
 function acquireMatchResources(matches: Array<AnyRouteMatch>): void {
   for (const match of matches as Array<WorkMatch>) {
     const flight = match._flight
     if (flight) {
-      flight[2]++
+      flight[2 /* leases */]++
     }
   }
 }
@@ -584,7 +590,7 @@ function setFetching(
   owner?: AbortController,
 ): void {
   match.isFetching = value
-  if (owner && router._tx?.[0] !== owner) {
+  if (owner && router._tx?.[0 /* controller */] !== owner) {
     return
   }
   const store = router.stores.byRoute.get(match.routeId)
@@ -603,7 +609,7 @@ function getLoaderContext(
   parentMatchPromise: Promise<WorkMatch> | undefined,
   preload: boolean,
 ): LoaderFnContext {
-  const location = lane[0]
+  const location = lane[0 /* location */]
   return {
     params: match.params,
     location,
@@ -638,13 +644,12 @@ async function loadResource(
   }
 
   let flight = match._flight
-  let joined = !!flight
   setFetching(router, match, 'loader', owner)
   try {
-    for (;;) {
-      if (!flight) {
-        const controller = new AbortController()
-        const outcome = Promise.resolve()
+    if (!flight) {
+      const controller = new AbortController()
+      flight = [
+        Promise.resolve()
           .then(() =>
             loader(
               getLoaderContext(
@@ -663,34 +668,35 @@ async function loadResource(
             (cause) => normalize(cause, true, route.id),
           )
           .then((result): LoaderOutcome => {
-            return result[0] === ERROR && match._flight === flight
-              ? normalizeError(route, result[1])
+            // The registry controls discovery; leases keep current consumers
+            // sharing the same terminal outcome.
+            if (
+              result[0 /* kind */] !== SUCCESS &&
+              router._flights?.get(match.id) === flight
+            ) {
+              router._flights!.delete(match.id)
+              if (!flight![2 /* leases */]) {
+                controller.abort()
+              }
+            }
+            return result[0 /* kind */] === ERROR && flight![2 /* leases */]
+              ? normalizeError(route, result[1 /* error */])
               : result
-          })
-        flight = [outcome, controller, 1]
-        ;(router._flights ??= new Map()).set(match.id, flight)
-      }
-      match._flight = flight
-      match.abortController = flight[1]
-      try {
-        const outcome = await waitFor(flight[0], signal)
-        if (!joined || outcome[0] === SUCCESS || outcome[0] === REDIRECTED) {
-          return outcome
-        }
-      } catch (cause) {
-        if (cause === signal) {
-          releaseFlight(router, match)
-          return [CANCELED]
-        }
-        throw cause
-      }
-      releaseFlight(router, match)
-      if (signal.aborted) {
-        return [CANCELED]
-      }
-      flight = undefined
-      joined = false
+          }),
+        controller,
+        1,
+      ]
+      ;(router._flights ??= new Map()).set(match.id, flight)
     }
+    match._flight = flight
+    match.abortController = flight[1 /* controller */]
+    return await waitFor(flight[0 /* outcome */], signal)
+  } catch (cause) {
+    if (cause !== signal) {
+      throw cause
+    }
+    releaseFlight(router, match)
+    return [CANCELED]
   } finally {
     setFetching(router, match, false, owner)
   }
@@ -701,14 +707,14 @@ function settleInto(
   result: LoaderOutcome,
   preload: boolean,
 ): asserts match is SettledMatch {
-  if (result[0] === SUCCESS) {
-    match.loaderData = result[1]
+  if (result[0 /* kind */] === SUCCESS) {
+    match.loaderData = result[1 /* data */]
     match.error = undefined
     match.status = 'success'
     match.invalid = false
     match.updatedAt = Date.now()
     match.preload = preload
-  } else if (result[0] !== REDIRECTED) {
+  } else if (result[0 /* kind */] !== REDIRECTED) {
     // Reduction installs only the selected terminal failure. Every other
     // settled attempt remains a renderable, stale match in that lane.
     match.status = 'success'
@@ -739,7 +745,7 @@ export function cacheLoaderMatch(
     context: {},
   } as WorkMatch
   if (cached._flight) {
-    cached._flight[2]++
+    cached._flight[2 /* leases */]++
   }
   router._cache.set(match.id, cached)
   if (current) {
@@ -751,11 +757,11 @@ function getParentSnapshot(
   match: WorkMatch,
   outcome: LoaderOutcome,
 ): WorkMatch {
-  if (outcome[0] === ERROR || outcome[0] === NOT_FOUND) {
+  if (outcome[0 /* kind */] === ERROR || outcome[0 /* kind */] === NOT_FOUND) {
     return {
       ...match,
-      status: outcome[0] === ERROR ? 'error' : 'notFound',
-      error: outcome[1],
+      status: outcome[0 /* kind */] === ERROR ? 'error' : 'notFound',
+      error: outcome[1 /* error */],
       _flight: undefined,
     }
   }
@@ -770,14 +776,14 @@ function createLoaderTask(
   semanticParent: Promise<WorkMatch> | undefined,
   options: ExecuteLaneOptions,
 ): Promise<WorkMatch> {
-  const match = lane[1][index]!
+  const match = lane[1 /* matches */][index]!
   const route = getRoute(router, match)
-  const preload = !!options[4]
+  const preload = !!options[4 /* preload */]
   const plannedCacheMatch = preload ? router._cache.get(match.id) : undefined
+  let configured
   let reload = false
   let reloadFailure: LoaderOutcome | undefined
   try {
-    let configured
     if (match.status === 'success') {
       configured = route.options.shouldReload
       if (typeof configured === 'function') {
@@ -787,14 +793,14 @@ function createLoaderTask(
             lane,
             match,
             route,
-            options[0],
+            options[0 /* controller */],
             semanticParent,
             preload,
           ),
         )
       }
-      if (!options[2]()) {
-        options[0].abort()
+      if (!options[2 /* isCurrent */]()) {
+        options[0 /* controller */].abort()
         reloadFailure = [CANCELED]
       }
     }
@@ -803,7 +809,7 @@ function createLoaderTask(
         reload = true
       } else {
         const staleAge =
-          options[4] || match.preload
+          options[4 /* preload */] || match.preload
             ? (route.options.preloadStaleTime ??
               router.options.defaultPreloadStaleTime ??
               30_000)
@@ -813,9 +819,9 @@ function createLoaderTask(
           configured ||
           (configured === undefined &&
             Date.now() - match.updatedAt >= staleAge &&
-            (options[6] ||
+            (options[6 /* forceStaleReload */] ||
               match.cause === 'enter' ||
-              options[3].some(
+              options[3 /* base */].some(
                 (candidate) =>
                   candidate.routeId === match.routeId &&
                   candidate.id !== match.id,
@@ -831,12 +837,27 @@ function createLoaderTask(
   const routeLoader = route.options.loader
   const loader =
     typeof routeLoader === 'function' ? routeLoader : routeLoader?.handler
+  let donor =
+    (!preload || route.options.preload !== false) &&
+    routeLoader &&
+    !(process.env.NODE_ENV !== 'production' && router._tx?.[6 /* refresh */])
+      ? router._flights?.get(match.id)
+      : undefined
+  if (donor === match._flight || reloadFailure) {
+    donor = undefined
+  } else if (donor && !reload && !preload && configured === undefined) {
+    // Normal cache policy accepts an already-running generation even when this
+    // lane itself would not have started another loader.
+    reload = true
+  } else if (!reload) {
+    donor = undefined
+  }
   const background = !!(
     routeLoader &&
     reload &&
     match.status === 'success' &&
     !preload &&
-    !options[5] &&
+    !options[5 /* sync */] &&
     ((typeof routeLoader === 'function'
       ? undefined
       : routeLoader?.staleReloadMode) ??
@@ -845,20 +866,19 @@ function createLoaderTask(
   const loaded = reload && (!preload || route.options.preload !== false)
   const blocking =
     loaded && !background && (match.status !== 'success' || !!routeLoader)
+  const onLazyReady =
+    route.lazyFn && route._lazy !== true ? options[8 /* onReady */] : undefined
   if (loaded && !routeLoader) {
     match.invalid = false
     match.updatedAt = Date.now()
   }
-  let donor = loaded && routeLoader ? router._flights?.get(match.id) : undefined
-  if (donor === match._flight) {
-    donor = undefined
-  } else if (donor) {
-    donor[2]++
+  if (donor) {
+    donor[2 /* leases */]++
   }
   if (blocking) {
     const acceptedFlight = match._flight
     match._flight = donor
-    releaseOwnedFlight(router, match.id, acceptedFlight)?.abort()
+    releaseOwnedFlight(router, match, acceptedFlight)?.abort()
     // A successful route without a loader has no blocking work to present. It
     // still gets a task so its chunk and derived assets participate in the
     // lane, but putting it back into pending would hide an already-rendered
@@ -866,7 +886,7 @@ function createLoaderTask(
     if (match.status === 'success') {
       match.status = 'pending'
     }
-    options[8]?.()
+    options[8 /* onReady */]?.()
   }
   if (!loaded) {
     match.isFetching = false
@@ -883,13 +903,17 @@ function createLoaderTask(
           loader,
           semanticParent,
           preload,
-          options[0],
+          options[0 /* controller */],
         )
   const outcome = rawOutcome.then((result) => {
     if (blocking) {
       settleInto(match, result, preload)
-      if (result[0] === SUCCESS) {
-        if (preload && routeLoader) {
+      if (result[0 /* kind */] === SUCCESS) {
+        if (
+          preload &&
+          routeLoader &&
+          !options[0 /* controller */].signal.aborted
+        ) {
           cacheLoaderMatch(router, match, plannedCacheMatch)
         }
         // A route is renderable only after both its data and normal component
@@ -901,13 +925,10 @@ function createLoaderTask(
   })
 
   const rawChunkFailure = waitFor(
-    Promise.resolve().then(() => loadRouteChunk(route)),
-    options[0].signal,
+    Promise.resolve().then(() => loadRouteChunk(route, undefined, onLazyReady)),
+    options[0 /* controller */].signal,
   ).then(
-    () => {
-      options[8]?.()
-      return undefined
-    },
+    () => undefined,
     (cause): IndexedOutcome => [
       index,
       normalizeLaneError(route, cause, options),
@@ -918,12 +939,12 @@ function createLoaderTask(
       if (
         blocking &&
         !failure &&
-        result[0] === SUCCESS &&
+        result[0 /* kind */] === SUCCESS &&
         match.status === 'pending' &&
-        options[2]()
+        options[2 /* isCurrent */]()
       ) {
         match.status = 'success'
-        options[8]?.()
+        options[8 /* onReady */]?.()
       }
       return failure
     }),
@@ -948,13 +969,18 @@ function createLoaderTask(
     loader,
     semanticParent,
     false,
-    options[0],
+    options[0 /* controller */],
   ).then((result) => {
     match.isFetching = false
     settleInto(candidate, result, false)
     return result
   })
-  ;(lane[2] ??= []).push([index, backgroundOutcome, chunkFailure, candidate])
+  ;(lane[2 /* background */] ??= []).push([
+    index,
+    backgroundOutcome,
+    chunkFailure,
+    candidate,
+  ])
   return backgroundOutcome.then((result) =>
     getParentSnapshot(candidate, result),
   )
@@ -967,10 +993,12 @@ async function getNotFoundBoundary(
   signal: AbortSignal,
   fallback = 0,
 ): Promise<number> {
-  const cause = indexed?.[1][1] as NotFoundError | undefined
+  const cause = indexed?.[1 /* outcome */][1 /* error or redirect */] as
+    | NotFoundError
+    | undefined
   let index = cause?.routeId
     ? matches.findIndex((match) => match.routeId === cause.routeId)
-    : (indexed?.[0] ?? matches.length - 1)
+    : (indexed?.[0 /* index */] ?? matches.length - 1)
   if (index < 0) {
     index = 0
   }
@@ -994,12 +1022,12 @@ async function getNotFoundBoundary(
 }
 
 function discardBackground(router: AnyRouter, lane: Lane<any>): void {
-  if (lane[2]) {
+  if (lane[2 /* background */]) {
     transferMatchResources(
       router,
-      lane[2].map((task) => task[3]),
+      lane[2 /* background */].map((task) => task[3 /* candidate */]),
     )
-    lane[2] = undefined
+    lane[2 /* background */] = undefined
   }
 }
 
@@ -1014,26 +1042,29 @@ async function settleTasks(
   try {
     await Promise.all(
       tasks.map((task) =>
-        task[1].then(async (outcome) => {
-          const taskIndex = task[0]
+        task[1 /* outcome */].then(async (outcome) => {
+          const taskIndex = task[0 /* index */]
           if (gate && taskIndex >= (await gate)) {
             return
           }
-          if (outcome[0] >= REDIRECTED) {
+          if (outcome[0 /* kind */] >= REDIRECTED) {
             throw [taskIndex, outcome] as IndexedOutcome
           }
-          if (!loaderFailure && outcome[0] !== SUCCESS) {
+          if (!loaderFailure && outcome[0 /* kind */] !== SUCCESS) {
             loaderFailure = [taskIndex, outcome]
             // Every started descendant must settle before an ordinary failure
             // wins because a redirect from any of them remains control flow.
             await Promise.all(
               (redirectTasks ?? []).map((nextTask) => {
-                if (nextTask[0] <= taskIndex) {
+                if (nextTask[0 /* index */] <= taskIndex) {
                   return
                 }
-                return nextTask[1].then((nextOutcome) => {
-                  if (nextOutcome[0] === REDIRECTED) {
-                    throw [nextTask[0], nextOutcome] as IndexedOutcome
+                return nextTask[1 /* outcome */].then((nextOutcome) => {
+                  if (nextOutcome[0 /* kind */] === REDIRECTED) {
+                    throw [
+                      nextTask[0 /* index */],
+                      nextOutcome,
+                    ] as IndexedOutcome
                   }
                 })
               }),
@@ -1057,43 +1088,43 @@ async function reduceLane(
   settlement: Promise<IndexedOutcome | undefined>,
   onReady?: () => void,
 ): Promise<ReducedLane | ControlOutcome> {
-  const matches = lane[1]
+  const matches = lane[1 /* matches */]
   let failure = await settlement
   let redirectLimitExceeded = false
   const plannedBoundary = matches.findIndex((match) => match._notFound)
   const boundaryOf = (found: IndexedOutcome) =>
-    found[1][0] === NOT_FOUND
+    found[1 /* outcome */][0 /* kind */] === NOT_FOUND
       ? getNotFoundBoundary(router, matches, found, controller.signal)
-      : found[0]
+      : found[0 /* index */]
   let readinessEnd = plannedBoundary < 0 ? matches.length : plannedBoundary
 
-  if ((failure?.[1][0] ?? 0) >= REDIRECTED) {
+  if ((failure?.[1 /* outcome */][0 /* kind */] ?? 0) >= REDIRECTED) {
     readinessEnd = 0
   } else if (failure) {
-    readinessEnd = failure[2] ??= await boundaryOf(failure)
+    readinessEnd = failure[2 /* boundary */] ??= await boundaryOf(failure)
     for (const task of tasks) {
-      if (task[0] >= readinessEnd) {
+      if (task[0 /* index */] >= readinessEnd) {
         break
       }
-      const outcome = await task[1]
+      const outcome = await task[1 /* outcome */]
       // Presence means a loader previously succeeded, even with `undefined`.
       if (
-        outcome[0] !== SUCCESS &&
-        outcome[0] < REDIRECTED &&
-        !('loaderData' in matches[task[0]]!)
+        outcome[0 /* kind */] !== SUCCESS &&
+        outcome[0 /* kind */] < REDIRECTED &&
+        !('loaderData' in matches[task[0 /* index */]]!)
       ) {
-        failure = [task[0], outcome]
-        readinessEnd = failure[2] = await boundaryOf(failure)
+        failure = [task[0 /* index */], outcome]
+        readinessEnd = failure[2 /* boundary */] = await boundaryOf(failure)
         break
       }
     }
   }
 
   for (const task of tasks) {
-    if (task[0] >= readinessEnd) {
+    if (task[0 /* index */] >= readinessEnd) {
       break
     }
-    const chunkFailure = await task[2]
+    const chunkFailure = await task[2 /* chunkFailure */]
     if (!chunkFailure) {
       continue
     }
@@ -1101,11 +1132,11 @@ async function reduceLane(
     break
   }
 
-  if ((failure?.[1][0] ?? 0) >= REDIRECTED) {
-    const outcome = failure![1]
+  if ((failure?.[1 /* outcome */][0 /* kind */] ?? 0) >= REDIRECTED) {
+    const outcome = failure![1 /* outcome */]
     if (
-      outcome[0] !== REDIRECTED ||
-      outcome[1].options.reloadDocument ||
+      outcome[0 /* kind */] !== REDIRECTED ||
+      outcome[1 /* redirect */].options.reloadDocument ||
       redirects < 20
     ) {
       discardBackground(router, lane)
@@ -1116,13 +1147,13 @@ async function reduceLane(
   }
 
   const boundary = failure
-    ? (failure[2] ?? (await boundaryOf(failure)))
+    ? (failure[2 /* boundary */] ?? (await boundaryOf(failure)))
     : plannedBoundary
   if (boundary >= 0) {
-    const outcome = failure?.[1]
-    const kind = outcome?.[0]
+    const outcome = failure?.[1 /* outcome */]
+    const kind = outcome?.[0 /* kind */]
     const match = matches[boundary]!
-    const cause = outcome?.[1]
+    const cause = outcome?.[1 /* error or redirect */]
     const install = () => {
       if (outcome) {
         match._notFound = undefined
@@ -1169,9 +1200,11 @@ async function reduceLane(
     } else if (redirectLimitExceeded) {
       controller.abort()
       await Promise.all([
-        ...tasks.map((task) => task[1]),
-        ...tasks.map((task) => task[2]),
-        ...(lane[2] ?? []).map((task) => task[1]),
+        ...tasks.map((task) => task[1 /* outcome */]),
+        ...tasks.map((task) => task[2 /* chunkFailure */]),
+        ...(lane[2 /* background */] ?? []).map(
+          (task) => task[1 /* outcome */],
+        ),
       ])
       discardBackground(router, lane)
       transferMatchResources(router, matches)
@@ -1187,9 +1220,9 @@ export async function projectLane(
   lane: ReducedLane,
   signal: AbortSignal,
   start = 0,
-  end = lane[1].length,
+  end = lane[1 /* matches */].length,
 ): Promise<ProjectedLane> {
-  const matches = lane[1]
+  const matches = lane[1 /* matches */]
   for (let index = start; index < end; index++) {
     const match = matches[index]!
     const routeOptions = getRoute(router, match).options
@@ -1239,9 +1272,9 @@ async function executeClientLane(
   if (router.options.notFoundMode !== 'root' && plannedBoundary >= 0) {
     const boundary = await getNotFoundBoundary(
       router,
-      matched[1],
+      matched[1 /* matches */],
       undefined,
-      options[0].signal,
+      options[0 /* controller */].signal,
       plannedBoundary,
     )
     if (boundary !== plannedBoundary) {
@@ -1251,42 +1284,54 @@ async function executeClientLane(
     plannedBoundary = boundary
   }
   let end = plannedBoundary < 0 ? matches.length : plannedBoundary + 1
-  // From here on `matched` is contextualized: `contextualize` communicates
-  // through mutation plus a failure return, so the phase brand is asserted at
-  // the two use sites below rather than granted by a (byte-costing) return.
-  const failure = await contextualize(router, matched, options, end)
-  if (failure) {
-    options[5] = true
-  }
   const tasks: Array<LoaderTask> = []
-  const start = options[7] ?? 0
+  const start = options[7 /* resolvedPrefix */] ?? 0
   let semanticParent = start
-    ? Promise.resolve(matched[1][start - 1]!)
+    ? Promise.resolve(matched[1 /* matches */][start - 1]!)
     : undefined
-  end = failure?.[0] ?? end
-  if (failure?.[1][0] === NOT_FOUND) {
-    failure[2] = await getNotFoundBoundary(
-      router,
-      matched[1],
-      failure,
-      options[0].signal,
-    )
-    end = Math.min(end, failure[2] + 1)
-  } else if ((failure?.[1][0] ?? 0) >= REDIRECTED) {
-    end = 0
+  const planSuccessfulLane = () => {
+    for (let index = start; index < end; index++) {
+      if (options[0 /* controller */].signal.aborted) {
+        break
+      }
+      semanticParent = createLoaderTask(
+        router,
+        matched as ContextualizedLane,
+        index,
+        tasks,
+        semanticParent,
+        options,
+      )
+    }
   }
-  for (let index = start; index < end; index++) {
-    if (options[0].signal.aborted) {
-      break
+  // From here on `matched` is contextualized: `contextualize` communicates
+  // through mutation plus a failure return, so the phase brand is asserted at
+  // the two use sites below rather than granted by a (byte-costing) return.
+  const failure = await contextualize(
+    router,
+    matched,
+    options,
+    end,
+    planSuccessfulLane,
+  )
+  if (failure) {
+    options[5 /* sync */] = true
+    end = failure[0 /* index */]
+    if (failure[1 /* outcome */][0 /* kind */] === NOT_FOUND) {
+      failure[2 /* boundary */] = await getNotFoundBoundary(
+        router,
+        matched[1 /* matches */],
+        failure,
+        options[0 /* controller */].signal,
+      )
+      end = Math.min(end, failure[2 /* boundary */] + 1)
+    } else if (failure[1 /* outcome */][0 /* kind */] >= REDIRECTED) {
+      end = 0
     }
-    semanticParent = createLoaderTask(
-      router,
-      matched as ContextualizedLane,
-      index,
-      tasks,
-      semanticParent,
-      options,
-    )
+    planSuccessfulLane()
+  }
+  if (options[2 /* isCurrent */]() && !options[4 /* preload */]) {
+    releaseUnownedFlights(router)
   }
   let reduced: ReducedLane | ControlOutcome
   try {
@@ -1294,21 +1339,21 @@ async function executeClientLane(
       router,
       matched as ContextualizedLane,
       tasks,
-      options[0],
-      options[1],
-      settleTasks(tasks, failure, matched[2]),
-      options[8],
+      options[0 /* controller */],
+      options[1 /* redirects */],
+      settleTasks(tasks, failure, matched[2 /* background */]),
+      options[8 /* onReady */],
     )
-    if (matched[2]?.length) {
-      matched[3] = settleTasks(
-        matched[2],
+    if (matched[2 /* background */]?.length) {
+      matched[3 /* backgroundSettlement */] = settleTasks(
+        matched[2 /* background */],
         undefined,
         undefined,
         reduction.then(
           (foreground) =>
             isControl(foreground)
               ? 0
-              : _getRenderedMatches(foreground[1]).length,
+              : _getRenderedMatches(foreground[1 /* matches */]).length,
           () => 0,
         ),
       )
@@ -1324,8 +1369,10 @@ async function executeClientLane(
   return projectLane(
     router,
     reduced,
-    options[0].signal,
-    options[7] === reduced[1].length ? options[7] : 0,
+    options[0 /* controller */].signal,
+    options[7 /* resolvedPrefix */] === reduced[1 /* matches */].length
+      ? options[7 /* resolvedPrefix */]
+      : 0,
   )
 }
 
@@ -1384,71 +1431,83 @@ function offerPending(router: CoordinatorRouter, tx: LoadTransaction): void {
   }
   let session = router._pending
   let tookOver = false
-  const sessionMatchId = session?.[0][3][session[1]]?.id
-  if (session?.[0] !== tx) {
-    if (session && tx[3][session[1]]?.id === sessionMatchId) {
-      session[0] = tx
+  const sessionMatchId =
+    session?.[0 /* owner */][3 /* matches */][session[1 /* boundary */]]?.id
+  if (session?.[0 /* owner */] !== tx) {
+    if (
+      session &&
+      tx[3 /* matches */][session[1 /* boundary */]]?.id === sessionMatchId
+    ) {
+      session[0 /* owner */] = tx
       tookOver = true
     } else {
-      clearTimeout(session?.[3])
+      clearTimeout(session?.[3 /* timer */])
       router._pending = session = undefined
     }
   }
-  const config = pendingConfig(router, tx[3])
+  const config = pendingConfig(router, tx[3 /* matches */])
   if (!config) {
     return
   }
   const [delay, boundary, min, component] = config
-  const matchId = tx[3][boundary]!.id
-  if (!session || session[1] !== boundary || sessionMatchId !== matchId) {
+  const matchId = tx[3 /* matches */][boundary]!.id
+  if (
+    !session ||
+    session[1 /* boundary */] !== boundary ||
+    sessionMatchId !== matchId
+  ) {
     // Hydration and redirects can preserve pending presentation without a session.
     // Do not delay it again; conservatively start pendingMinMs from now.
-    clearTimeout(session?.[3])
+    clearTimeout(session?.[3 /* timer */])
     const presented = router.stores.matches.get()[boundary]
     const visible = presented?.id === matchId && presented.status === 'pending'
     router._pending = session = [
       tx,
       boundary,
-      visible ? Date.now() + min : tx[4] + delay,
+      visible ? Date.now() + min : tx[4 /* startedAt */] + delay,
       undefined,
       visible ? Promise.resolve(true) : undefined,
       component,
     ]
   }
-  if (session[4] && !tookOver && session[5] === component) {
+  if (
+    session[4 /* ack */] &&
+    !tookOver &&
+    session[5 /* component */] === component
+  ) {
     return
   }
-  session[5] = component
-  if (!session[4]) {
-    clearTimeout(session[3])
-    const remaining = session[2] - Date.now()
+  session[5 /* component */] = component
+  if (!session[4 /* ack */]) {
+    clearTimeout(session[3 /* timer */])
+    const remaining = session[2 /* deadline */] - Date.now()
     if (remaining > 0) {
-      session[3] = setTimeout(() => {
+      session[3 /* timer */] = setTimeout(() => {
         offerPending(router, tx)
       }, remaining)
       return
     }
-    session[2] = 0
+    session[2 /* deadline */] = 0
   }
-  const offered = tx[3].map((match) => ({
+  const offered = tx[3 /* matches */].map((match) => ({
     ...match,
     _flight: undefined,
   }))
   offered[boundary]!.status = 'pending'
   const ack = router
-    .startTransition(() => router.stores.setMatches(offered), offered, true)
+    .startTransition(() => router.stores.setMatches(offered), offered)
     .then((rendered) => {
       if (
         rendered &&
         router._pending === session &&
-        session[4] === ack &&
-        !session[2]
+        session[4 /* ack */] === ack &&
+        !session[2 /* deadline */]
       ) {
-        session[2] = Date.now() + min
+        session[2 /* deadline */] = Date.now() + min
       }
       return rendered
     })
-  session[4] = ack
+  session[4 /* ack */] = ack
 }
 
 /**
@@ -1457,8 +1516,8 @@ function offerPending(router: CoordinatorRouter, tx: LoadTransaction): void {
  */
 function finishPending(router: CoordinatorRouter, tx: LoadTransaction): void {
   const session = router._pending
-  if (session?.[0] === tx) {
-    clearTimeout(session[3])
+  if (session?.[0 /* owner */] === tx) {
+    clearTimeout(session[3 /* timer */])
     router._pending = undefined
   }
 }
@@ -1472,7 +1531,7 @@ function publishMatches(
 }
 
 function discardLane(router: AnyRouter, lane: ProjectedLane): void {
-  transferMatchResources(router, lane[1])
+  transferMatchResources(router, lane[1 /* matches */])
   discardBackground(router, lane)
 }
 
@@ -1534,7 +1593,7 @@ function commitMatches(
     )
   }
   // The lane becomes committed before publication can synchronously reenter.
-  tx[3] = []
+  tx[3 /* matches */] = []
   router._cache = cached
   publishMatches(router, matches)
   transferMatchResources(
@@ -1559,7 +1618,7 @@ function commitRefreshMatches(
   const cached = new Map<string, AnyRouteMatch>()
   // Delay releasing the previous owners until the HMR render is acknowledged.
   // Old generations must not become reusable cache entries after refresh.
-  tx[3] = []
+  tx[3 /* matches */] = []
   router._cache = cached
   checkpoint.previousMatches = previous
   checkpoint.previousCache = previousCached
@@ -1595,7 +1654,7 @@ function rollbackPublication(
   if (
     !checkpoint.published ||
     router._tx !== tx ||
-    router._committed !== lane[1]
+    router._committed !== lane[1 /* matches */]
   ) {
     settlePublication(router, checkpoint)
     return false
@@ -1625,7 +1684,7 @@ function rollbackPublication(
     router.stores.status.set('idle')
     router.stores.setMatches(checkpoint.previousPresentation)
   })
-  tx[0].abort()
+  tx[0 /* controller */].abort()
   transferMatchResources(router, discarded, restored)
   discardBackground(router, lane)
   if (router._tx === tx && router._commitPromise === checkpoint.commitPromise) {
@@ -1641,17 +1700,18 @@ async function transitionRefresh(
   lane: ProjectedLane,
   changeInfo: ReturnType<typeof getLocationChangeInfo>,
 ): Promise<boolean | undefined> {
+  const refresh = tx[6 /* refresh */]!
   const checkpoint: PublicationCheckpoint = {
     previousMatches: router._committed,
-    previousPresentation: tx[6]?.[0] ?? router.stores.matches.get(),
+    previousPresentation: refresh[0 /* presentation */],
     previousCache: router._cache,
     commitPromise: router._commitPromise,
     published: false,
   }
   const commit = () => {
     finishPending(router, tx)
-    router._rollbackRefresh = rollback
-    commitRefreshMatches(router, tx, lane[1], checkpoint)
+    refresh[2 /* rollback */] = rollback
+    commitRefreshMatches(router, tx, lane[1 /* matches */], checkpoint)
     if (!checkpoint.published || router._tx !== tx) {
       return
     }
@@ -1661,25 +1721,25 @@ async function transitionRefresh(
     }
   }
   const rollback = () => {
-    if (router._rollbackRefresh === rollback) {
-      router._rollbackRefresh = undefined
+    if (refresh[2 /* rollback */] === rollback) {
+      refresh[2 /* rollback */] = undefined
     }
     const restored = rollbackPublication(router, tx, lane, checkpoint)
     router._cancelTransition?.()
     return restored
   }
   try {
-    const rendered = await router.startTransition(commit, lane[1])
-    if (router._rollbackRefresh === rollback) {
-      router._rollbackRefresh = undefined
+    const rendered = await router.startTransition(commit, lane[1 /* matches */])
+    if (refresh[2 /* rollback */] === rollback) {
+      refresh[2 /* rollback */] = undefined
     }
     if (checkpoint.published) {
-      const handoff = tx[6]?.[1]
+      const handoff = refresh[1 /* handoff */]
       if (handoff && router._handoff === handoff) {
-        handoff[1]()
+        handoff[1 /* finish */]()
       }
       if (router._tx === tx) {
-        tx[6] = undefined
+        tx[6 /* refresh */] = undefined
       }
     }
     settlePublication(router, checkpoint)
@@ -1698,7 +1758,7 @@ async function awaitCurrent(
 ): Promise<void> {
   let current = router._tx
   while (current && current !== owner) {
-    await current[5]
+    await current[5 /* done */]
     if (router._tx === current) {
       return
     }
@@ -1715,7 +1775,7 @@ async function followRedirect(
     ...redirect.options,
     replace: true,
     ignoreBlocker: true,
-    _redirects: tx[1] + 1,
+    _redirects: tx[1 /* redirects */] + 1,
   } as any)
 }
 
@@ -1724,9 +1784,9 @@ function restoreCommitted(
   tx: LoadTransaction,
 ): void {
   finishPending(router, tx)
-  tx[0].abort()
-  transferMatchResources(router, tx[3])
-  tx[3] = []
+  tx[0 /* controller */].abort()
+  transferMatchResources(router, tx[3 /* matches */])
+  tx[3 /* matches */] = []
   if (router._tx !== tx) {
     return
   }
@@ -1750,15 +1810,22 @@ async function runBackground(
   const next = base.map((match) => ({ ...match }))
   acquireMatchResources(next)
   for (const task of tasks) {
-    releaseFlight(router, next[task[0]]!)
-    next[task[0]] = task[3]
+    releaseFlight(router, next[task[0 /* index */]]!)
+    next[task[0 /* index */]] = task[3 /* candidate */]
   }
   // Phase jump: the clones inherit beforeLoad context from the committed
   // foreground lane, which already ran `contextualize` for these matches.
-  const lane = [tx[2], next] as ContextualizedLane
+  const lane = [tx[2 /* location */], next] as ContextualizedLane
   let reduced: ReducedLane | ControlOutcome
   try {
-    reduced = await reduceLane(router, lane, tasks, tx[0], tx[1], settlement)
+    reduced = await reduceLane(
+      router,
+      lane,
+      tasks,
+      tx[0 /* controller */],
+      tx[1 /* redirects */],
+      settlement,
+    )
   } catch (cause) {
     transferMatchResources(router, next)
     throw cause
@@ -1766,28 +1833,32 @@ async function runBackground(
   if (isControl(reduced)) {
     transferMatchResources(router, next)
     if (
-      reduced[0] === REDIRECTED &&
+      reduced[0 /* kind */] === REDIRECTED &&
       router._tx === tx &&
       router._committed === base
     ) {
-      await followRedirect(router, tx, reduced[1])
+      await followRedirect(router, tx, reduced[1 /* redirect */])
     }
     return
   }
-  const projected = await projectLane(router, reduced, tx[0].signal)
+  const projected = await projectLane(
+    router,
+    reduced,
+    tx[0 /* controller */].signal,
+  )
   if (router._tx !== tx || router._committed !== base) {
-    transferMatchResources(router, projected[1])
+    transferMatchResources(router, projected[1 /* matches */])
     return
   }
-  for (const match of projected[1] as Array<WorkMatch>) {
+  for (const match of projected[1 /* matches */] as Array<WorkMatch>) {
     const cached = router._cache.get(match.id) as WorkMatch | undefined
     if (cached?._flight && cached._flight === match._flight) {
       router._cache.delete(match.id)
       releaseFlight(router, cached)
     }
   }
-  publishMatches(router, projected[1])
-  transferMatchResources(router, base, projected[1])
+  publishMatches(router, projected[1 /* matches */])
+  transferMatchResources(router, base, projected[1 /* matches */])
 }
 
 async function runClientTransaction(
@@ -1797,13 +1868,11 @@ async function runClientTransaction(
   onReady?: () => void,
   sync?: boolean,
   resolvedPrefix?: number,
-  adopted?: ActivePreload,
-  retained?: ActivePreload,
 ): Promise<void> {
   const options: ExecuteLaneOptions = [
-    tx[0],
-    tx[1],
-    () => router._tx === tx && !!tx[3].length,
+    tx[0 /* controller */],
+    tx[1 /* redirects */],
+    () => router._tx === tx && !!tx[3 /* matches */].length,
     router._committed,
     undefined,
     sync,
@@ -1811,52 +1880,23 @@ async function runClientTransaction(
     resolvedPrefix,
     onReady,
   ]
-  let result: LaneResult
-  try {
-    result = adopted
-      ? await adopted[2]
-      : await executeClientLane(router, tx[2], tx[3], options)
-  } finally {
-    if (retained) {
-      discardPreload(router, retained)
-    }
-  }
-  if (
-    adopted &&
-    router._tx === tx &&
-    ((isControl(result) && result[0] === CANCELED) ||
-      (!isControl(result) &&
-        result[1].some(
-          (match) => match.status !== 'success' || match._notFound,
-        )))
-  ) {
-    // Successful loaders already seeded the cache; retry only the guard lane.
-    const donors = tx[3] as Array<WorkMatch>
-    tx[3] = []
-    transferMatchResources(router, donors)
-    tx[0].abort()
-    if (router._tx !== tx) {
-      return
-    }
-    const controller = new AbortController()
-    tx[0] = options[0] = controller
-    tx[3] = router.matchRoutes(tx[2], {
-      _controller: controller,
-    })
-    acquireMatchResources(tx[3])
-    result = await executeClientLane(router, tx[2], tx[3], options)
-  }
+  const result = await executeClientLane(
+    router,
+    tx[2 /* location */],
+    tx[3 /* matches */],
+    options,
+  )
 
   if (isControl(result)) {
-    if (result[0] === REDIRECTED && router._tx === tx) {
+    if (result[0 /* kind */] === REDIRECTED && router._tx === tx) {
       finishPending(router, tx)
-      transferMatchResources(router, tx[3])
-      tx[3] = []
+      transferMatchResources(router, tx[3 /* matches */])
+      tx[3 /* matches */] = []
       if (router._tx === tx) {
-        if (process.env.NODE_ENV !== 'production' && tx[6]) {
+        if (process.env.NODE_ENV !== 'production' && tx[6 /* refresh */]) {
           router._refreshNextLoad = true
         }
-        await followRedirect(router, tx, result[1])
+        await followRedirect(router, tx, result[1 /* redirect */])
       }
     } else {
       restoreCommitted(router, tx)
@@ -1864,36 +1904,40 @@ async function runClientTransaction(
     return
   }
   const pending = router._pending
-  if (pending?.[0] === tx) {
+  if (pending?.[0 /* owner */] === tx) {
     /**
      * Loading finished, so cancel any pending reveal. If the fallback rendered,
      * wait out the rest of `pendingMinMs` before replacing it. If it never
      * rendered, there is no minimum wait; if another load took it over, that
      * load owns the deadline.
      */
-    clearTimeout(pending[3])
-    if (pending[4]) {
-      const signal = tx[0].signal
+    clearTimeout(pending[3 /* timer */])
+    if (pending[4 /* ack */]) {
+      const signal = tx[0 /* controller */].signal
       let rendered = false
       try {
-        rendered = await waitFor(pending[4], signal)
+        rendered = await waitFor(pending[4 /* ack */], signal)
       } catch (cause) {
         if (cause !== signal) {
           throw cause
         }
       }
-      if (rendered && router._pending === pending && pending[0] === tx) {
-        const remaining = pending[2] - Date.now()
+      if (
+        rendered &&
+        router._pending === pending &&
+        pending[0 /* owner */] === tx
+      ) {
+        const remaining = pending[2 /* deadline */] - Date.now()
         if (remaining > 0) {
           try {
             await waitFor(
               new Promise<void>((resolve) => {
-                pending[3] = setTimeout(resolve, remaining)
+                pending[3 /* timer */] = setTimeout(resolve, remaining)
               }),
               signal,
             )
           } catch {}
-          clearTimeout(pending[3])
+          clearTimeout(pending[3 /* timer */])
         }
       }
     }
@@ -1903,12 +1947,12 @@ async function runClientTransaction(
     discardLane(router, result)
     return
   }
-  const toLocation = tx[2]
+  const toLocation = tx[2 /* location */]
   const changeInfo = getLocationChangeInfo(
     toLocation,
     router.stores.resolvedLocation.get(),
   )
-  const background = result[2]
+  const background = result[2 /* background */]
   await router.startViewTransition(async () => {
     if (router._tx !== tx) {
       discardLane(router, result)
@@ -1916,7 +1960,7 @@ async function runClientTransaction(
     }
     const commit = () => {
       finishPending(router, tx)
-      commitMatches(router, tx, result[1], resolvedPrefix)
+      commitMatches(router, tx, result[1 /* matches */], resolvedPrefix)
       if (router._tx !== tx) {
         return
       }
@@ -1926,12 +1970,12 @@ async function runClientTransaction(
       }
     }
     const rendered =
-      process.env.NODE_ENV !== 'production' && tx[6]
+      process.env.NODE_ENV !== 'production' && tx[6 /* refresh */]
         ? await transitionRefresh(router, tx, result, changeInfo)
-        : await router.startTransition(commit, result[1])
+        : await router.startTransition(commit, result[1 /* matches */])
     if (
       process.env.NODE_ENV !== 'production' &&
-      tx[6] &&
+      tx[6 /* refresh */] &&
       rendered === undefined
     ) {
       return
@@ -1944,9 +1988,13 @@ async function runClientTransaction(
       // Publish refreshes only after the foreground render acknowledgement.
       // Otherwise a fast refresh can replace the acknowledged generation
       // before the framework commits it and strand the navigation.
-      runBackground(router, tx, result[1], background, result[3]!).catch(
-        console.error,
-      )
+      runBackground(
+        router,
+        tx,
+        result[1 /* matches */],
+        background,
+        result[3 /* backgroundSettlement */]!,
+      ).catch(console.error)
     }
     router.batch(() => {
       router.stores.resolvedLocation.set(toLocation)
@@ -1968,12 +2016,12 @@ async function runClientTransaction(
 
 export async function loadClientRoute(
   router: CoordinatorRouter,
-  opts?: { sync?: boolean; _dedupe?: boolean },
+  opts?: { sync?: boolean },
 ): Promise<void> {
   let rematerialize = false
   if (process.env.NODE_ENV !== 'production') {
-    router._rollbackRefresh?.()
-    rematerialize = !!router._refreshNextLoad || !!router._tx?.[6]
+    router._tx?.[6 /* refresh */]?.[2 /* rollback */]?.()
+    rematerialize = !!router._refreshNextLoad || !!router._tx?.[6 /* refresh */]
   }
   const refreshPresentation = rematerialize
     ? router.stores.matches.get()
@@ -1989,121 +2037,73 @@ export async function loadClientRoute(
     pendingLocation?.href === location.href
       ? (pendingLocation._redirects ?? 0)
       : 0
-  // A same-location navigation joins the transaction already loading it
-  // instead of restarting its work. Reload requests never carry the flag,
-  // and same-location redirects must restart the lane they came from.
-  if (
-    opts?._dedupe &&
-    !redirects &&
-    previousOwner &&
-    !rematerialize &&
-    previousOwner[2].href === location.href &&
-    router.stores.status.get() === 'pending'
-  ) {
-    await awaitCurrent(router)
-    return
-  }
   const handoff = router._handoff
-  const hydrationController = rematerialize ? undefined : handoff?.[0]()
+  const hydrationController = rematerialize
+    ? undefined
+    : handoff?.[0 /* claim */]()
   const preflight = new AbortController()
   const previousPreflight = router._preflight
   router._preflight = preflight
   if (!rematerialize && !hydrationController) {
-    handoff?.[1]()
+    handoff?.[1 /* finish */]()
   }
   previousPreflight?.abort()
-  if (preflight.signal.aborted || router._tx !== previousOwner) {
+  // The preflight controller is not exposed to route hooks. Every replacement
+  // aborts its predecessor, so a live signal is the sole authority here.
+  if (preflight.signal.aborted) {
     await awaitCurrent(router, previousOwner)
     return
   }
 
   const changeInfo = getLocationChangeInfo(location, resolvedLocation)
   router.emit({ type: 'onBeforeNavigate', ...changeInfo })
-  if (!preflight.signal.aborted && router._tx === previousOwner) {
+  if (!preflight.signal.aborted) {
     router.emit({ type: 'onBeforeLoad', ...changeInfo })
   }
-  if (preflight.signal.aborted || router._tx !== previousOwner) {
-    preflight.abort()
+  if (preflight.signal.aborted) {
     await awaitCurrent(router, previousOwner)
     return
   }
   const sameHref = previousLocation.href === location.href
-  let adopted = router._preloads?.get(location.href)
-  let retained: ActivePreload | undefined
-  if (rematerialize && adopted) {
-    router._preloads!.delete(location.href)
-    discardPreload(router, adopted)
-    adopted = undefined
-    if (preflight.signal.aborted || router._tx !== previousOwner) {
-      preflight.abort()
-      await awaitCurrent(router, previousOwner)
-      return
-    }
-  }
-  if (
-    adopted &&
-    (hydrationController ||
-      !samePreloadLane(
-        adopted,
-        router,
-        pendingLocation?.href === location.href ? pendingLocation : location,
-        redirects,
-      ))
-  ) {
-    router._preloads!.delete(location.href)
-    // Keep incompatible loader flights alive through the real lane's reload
-    // decisions so matching generations can still donate their work.
-    retained = adopted
-    adopted = undefined
-  }
   let matches: Array<AnyRouteMatch>
   let controller = preflight
-  let resolvedPrefix: number | undefined
-  if (adopted) {
-    controller = adopted[1]
-    matches = adopted[0]
-    router._preloads!.delete(location.href)
-  } else {
-    try {
-      matches =
-        process.env.NODE_ENV !== 'production' && rematerialize
-          ? router.matchRoutes(location, {
-              _controller: preflight,
-              _rematerialize: true,
-            })
-          : router.matchRoutes(location, { _controller: preflight })
-      acquireMatchResources(matches)
-    } catch (cause) {
-      preflight.abort()
-      if (retained) {
-        discardPreload(router, retained)
-      }
-      if (!isRedirect(cause)) {
-        if (process.env.NODE_ENV !== 'production' && rematerialize) {
-          router._refreshNextLoad = undefined
-        }
-        await awaitCurrent(router)
-        router._commitPromise?.resolve()
-        router._commitPromise = undefined
-        return
+  try {
+    matches =
+      process.env.NODE_ENV !== 'production' && rematerialize
+        ? router.matchRoutes(location, {
+            _controller: preflight,
+            _rematerialize: true,
+          })
+        : router.matchRoutes(location, { _controller: preflight })
+    acquireMatchResources(matches)
+  } catch (cause) {
+    preflight.abort()
+    if (!isRedirect(cause)) {
+      if (process.env.NODE_ENV !== 'production' && rematerialize) {
+        router._refreshNextLoad = undefined
       }
-      await router.navigate({
-        ...cause.options,
-        replace: true,
-        ignoreBlocker: true,
-      })
-      await awaitCurrent(router, previousOwner)
+      await awaitCurrent(router)
+      router._commitPromise?.resolve()
+      router._commitPromise = undefined
       return
     }
-    resolvedPrefix = hydrationController ? handoff![1](matches) : undefined
-    if (resolvedPrefix) {
-      controller = hydrationController!
-    } else {
-      hydrationController?.abort()
-    }
+    await router.navigate({
+      ...cause.options,
+      replace: true,
+      ignoreBlocker: true,
+    })
+    await awaitCurrent(router, previousOwner)
+    return
   }
-  if (router._preflight !== preflight || router._tx !== previousOwner) {
-    preflight.abort()
+  const resolvedPrefix = hydrationController
+    ? handoff![1 /* finish */](matches)
+    : undefined
+  if (resolvedPrefix) {
+    controller = hydrationController!
+  } else {
+    hydrationController?.abort()
+  }
+  if (preflight.signal.aborted) {
     transferMatchResources(router, matches)
     await awaitCurrent(router, previousOwner)
     return
@@ -2125,8 +2125,6 @@ export async function loadClientRoute(
           () => offerPending(router, tx),
           opts?.sync,
           resolvedPrefix,
-          adopted,
-          retained,
         ),
       )
       .catch(() => {
@@ -2137,13 +2135,10 @@ export async function loadClientRoute(
   ]
   if (process.env.NODE_ENV !== 'production' && rematerialize) {
     // `refreshPresentation` is always captured when `rematerialize` is set.
-    tx[6] = [refreshPresentation!, handoff]
+    tx[6 /* refresh */] = [refreshPresentation!, handoff]
     router._refreshNextLoad = undefined
   }
   router._tx = tx
-  if (!rematerialize && router._handoff === handoff) {
-    router._handoff = undefined
-  }
   if (previousOwner) {
     for (const match of router.stores.matches.get() as Array<WorkMatch>) {
       if (router._tx !== tx) {
@@ -2153,23 +2148,26 @@ export async function loadClientRoute(
         setFetching(router, match, false)
       }
     }
-    previousOwner[0].abort()
-    transferMatchResources(router, previousOwner[3])
+    previousOwner[0 /* controller */].abort()
+    transferPredecessorResources(
+      router,
+      previousOwner[3 /* matches */],
+      tx[3 /* matches */],
+    )
   }
   if (router._tx !== tx) {
-    transferMatchResources(router, tx[3])
-    tx[3] = []
+    transferMatchResources(router, tx[3 /* matches */])
+    tx[3 /* matches */] = []
     await awaitCurrent(router, tx)
     return
   }
-
   router.batch(() => {
     router.stores.status.set('pending')
     router.stores.location.set(location)
   })
   offerPending(router, tx)
   try {
-    await tx[5]
+    await tx[5 /* done */]
   } finally {
     await awaitCurrent(router, tx)
   }
@@ -2178,10 +2176,14 @@ export async function loadClientRoute(
 export async function refreshClientRoute(
   router: CoordinatorRouter,
 ): Promise<void> {
-  router._rollbackRefresh?.()
+  router._tx?.[6 /* refresh */]?.[2 /* rollback */]?.()
   const pending = router._tx
-  if (pending && !pending[6] && router.stores.status.get() === 'pending') {
-    await pending[5]
+  if (
+    pending &&
+    !pending[6 /* refresh */] &&
+    router.stores.status.get() === 'pending'
+  ) {
+    await pending[5 /* done */]
     if (router._tx !== pending) {
       await awaitCurrent(router, pending)
     }
@@ -2193,30 +2195,6 @@ export async function refreshClientRoute(
   await loadClientRoute(router, { sync: true })
 }
 
-function followPreloadRedirect(
-  router: CoordinatorRouter,
-  result: ControlOutcome,
-  location: ParsedLocation,
-  owner: LoadTransaction | undefined,
-  redirects: number,
-): Promise<Array<AnyRouteMatch> | undefined> | undefined {
-  if (
-    result[0] === REDIRECTED &&
-    !result[1].options.reloadDocument &&
-    router._tx === owner
-  ) {
-    return preloadClientRoute(
-      router,
-      {
-        ...result[1].options,
-        _fromLocation: location,
-      },
-      redirects + 1,
-    )
-  }
-  return
-}
-
 export async function preloadClientRoute(
   router: CoordinatorRouter,
   opts: any,
@@ -2225,96 +2203,70 @@ export async function preloadClientRoute(
   if (redirects > 20) {
     return
   }
-  const owner = router._tx
   if (
     process.env.NODE_ENV !== 'production' &&
-    (router._refreshNextLoad || owner?.[6])
+    (router._refreshNextLoad || router._tx?.[6 /* refresh */])
   ) {
     return
   }
   const location = opts._builtLocation ?? router.buildLocation(opts)
   const base = router._committed
   const controller = new AbortController()
-  let matches: Array<AnyRouteMatch> | undefined
-  let preload: ActivePreload | undefined
-  let replaced: ActivePreload | undefined
+  let matches: Array<AnyRouteMatch>
   try {
-    const pending = router._preloads?.get(location.href)
-    if (pending) {
-      if (samePreloadLane(pending, router, location, redirects)) {
-        const result = await pending[2]
-        return isControl(result)
-          ? followPreloadRedirect(router, result, location, owner, redirects)
-          : result[1]
-      }
-      router._preloads!.delete(location.href)
-      // Keep the superseded lane alive until this lane has made its reload
-      // decisions. Its active flights are the synchronous donor authority.
-      replaced = pending
-    }
     matches = router.matchRoutes(location, {
       _controller: controller,
     })
     acquireMatchResources(matches)
-    const promise = Promise.resolve()
-      .then(() =>
-        executeClientLane(router, location, matches!, [
-          controller,
-          redirects,
-          // Preload lanes run to completion even when unrelated navigations
-          // commit: finished work seeds the cache, and adoption safety is
-          // enforced independently by samePreloadLane's base identity check.
-          () => true,
-          base,
-          true,
-        ]),
-      )
-      .finally(() => {
-        if (replaced) {
-          discardPreload(router, replaced)
-        }
-      })
-    preload = [
-      matches,
-      controller,
-      promise,
-      base,
-      laneInputs(router, location),
-      redirects,
-    ]
-    ;(router._preloads ??= new Map()).set(location.href, preload)
-    const result = await promise
-    if (router._preloads?.get(location.href) !== preload) {
-      return isControl(result) ? undefined : result[1]
+  } catch (cause) {
+    controller.abort()
+    if (!isNotFound(cause)) {
+      console.error(cause)
     }
-    router._preloads.delete(location.href)
-    if (isControl(result)) {
-      controller.abort()
+    return
+  }
+  ;(router._preloads ??= new Map()).set(controller, matches)
+  let active: boolean
+  try {
+    let result: LaneResult
+    try {
+      result = await executeClientLane(router, location, matches, [
+        controller,
+        redirects,
+        // Preload lanes run to completion even when unrelated navigations commit:
+        // finished work seeds the cache.
+        () => true,
+        base,
+        true,
+      ])
+    } finally {
+      active = router._preloads.delete(controller)
       transferMatchResources(router, matches)
-      return followPreloadRedirect(router, result, location, owner, redirects)
-    }
-
-    transferMatchResources(router, result[1])
-    controller.abort()
-    return result[1]
-  } catch (cause) {
-    if (!preload || router._preloads?.get(location.href) === preload) {
-      if (preload) {
-        router._preloads!.delete(location.href)
-      }
       controller.abort()
-      if (matches) {
-        transferMatchResources(router, matches)
-      }
     }
-    if (router._tx !== owner) {
-      return
+    if (!isControl(result)) {
+      return result[1 /* matches */]
+    }
+    if (
+      active &&
+      result[0 /* kind */] === REDIRECTED &&
+      !result[1 /* redirect */].options.reloadDocument
+    ) {
+      return preloadClientRoute(
+        router,
+        {
+          ...result[1 /* redirect */].options,
+          _fromLocation: location,
+        },
+        redirects + 1,
+      )
     }
+  } catch (cause) {
     if (!isNotFound(cause)) {
       console.error(cause)
     }
-    return
   }
+  return
 }
 
 // --- SSR hydration (client entry via @tanstack/router-core/ssr/client) ---
@@ -2352,12 +2304,13 @@ export async function hydrate(router: AnyRouter): Promise<void> {
     )
   }
   router.ssr = { manifest: dehydratedRouter!.manifest }
-  const nonce = (
-    document.querySelector('meta[property="csp-nonce"]') as
-      | HTMLMetaElement
-      | undefined
-  )?.content
-  router.options.ssr = { nonce }
+  router.options.ssr = {
+    nonce: (
+      document.querySelector('meta[property="csp-nonce"]') as
+        | HTMLMetaElement
+        | undefined
+    )?.content,
+  }
 
   const dehydratedMatches = dehydratedRouter!.matches
 
@@ -2365,22 +2318,14 @@ export async function hydrate(router: AnyRouter): Promise<void> {
   const previousPreflight = router._preflight
   router._preflight = controller
   previousPreflight?.abort()
-  const retire = (cause?: unknown) => {
-    if (router._preflight === controller) {
-      router._preflight = undefined
-    }
-    controller.abort(cause)
-    return false
-  }
-  const isCurrent = () =>
-    (!router._tx &&
-      router._preflight === controller &&
-      !controller.signal.aborted) ||
-    retire()
+  // Route context can abort this controller itself. Only a new slot owner
+  // supersedes hydration.
+  const isCurrent = () => router._preflight === controller
 
   let location!: AnyRouter['latestLocation']
   let candidates!: Array<AnyRouteMatch>
-  let handoffInputs!: ReturnType<typeof laneInputs>
+  let handoffHistoryHref!: string
+  let handoffHistoryState: unknown
   try {
     await waitFor(
       router.options.hydrate?.(dehydratedRouter!.dehydratedData),
@@ -2389,15 +2334,22 @@ export async function hydrate(router: AnyRouter): Promise<void> {
     if (!isCurrent()) {
       return
     }
+    // Hydration trusts transported context and beforeLoad. The raw history
+    // entry owns the handoff; route structure is verified after rematching.
+    const historyLocation = router.history.location
+    handoffHistoryHref = historyLocation.href
+    handoffHistoryState = historyLocation.state
     router.updateLatestLocation()
     location = router.latestLocation
     router.stores.location.set(location)
-    handoffInputs = laneInputs(router, location)
     candidates = router.matchRoutes(location, {
       _controller: controller,
     })
   } catch (cause) {
-    retire(cause)
+    if (isCurrent()) {
+      router._preflight = undefined
+    }
+    controller.abort(cause)
     if (cause !== controller.signal) {
       throw cause
     }
@@ -2492,8 +2444,6 @@ export async function hydrate(router: AnyRouter): Promise<void> {
       pendingBoundary ??= index
     }
   }
-  let verifiedContextEnd = verifiedAssetEnd
-
   if (
     !isTerminal &&
     committed.length === shared &&
@@ -2536,14 +2486,12 @@ export async function hydrate(router: AnyRouter): Promise<void> {
       chunkFailure++
     }
   } catch {
-    isCurrent()
     return
   }
   if (!isCurrent()) {
     return
   }
   if (chunkFailure < committed.length) {
-    verifiedContextEnd = Math.min(verifiedContextEnd, chunkFailure)
     retryFrom(chunkFailure)
   }
 
@@ -2553,7 +2501,9 @@ export async function hydrate(router: AnyRouter): Promise<void> {
     pendingBoundary === committed.length
       ? committed.length + 1
       : committed.length,
-    verifiedContextEnd,
+    // `chunks.length` keeps the pre-retry committed length, so a smaller
+    // `chunkFailure` is the exclusive bound of the verified context prefix.
+    chunkFailure < chunks.length ? chunkFailure : verifiedAssetEnd,
   )
   for (let index = 0; index < contextEnd; index++) {
     const match = candidates[index]!
@@ -2619,12 +2569,9 @@ export async function hydrate(router: AnyRouter): Promise<void> {
   let dataOnlyAssetEnd: number | undefined
   if (needsClientLoad && pendingBoundary !== undefined) {
     const boundary = presented[pendingBoundary]!
+    // A verified descendant proves this data-only boundary was nonterminal.
     dataOnlyAssetEnd =
-      boundary.status === 'success' &&
-      boundary.ssr === 'data-only' &&
-      boundary.error === undefined &&
-      !boundary._notFound &&
-      verifiedAssetEnd > pendingBoundary + 1
+      boundary.ssr === 'data-only' && verifiedAssetEnd > pendingBoundary + 1
         ? verifiedAssetEnd
         : undefined
     presented = presented.slice()
@@ -2636,29 +2583,33 @@ export async function hydrate(router: AnyRouter): Promise<void> {
     }
   }
 
-  const claim = () =>
-    needsClientLoad &&
-    !router._tx &&
-    router.latestLocation.state === location.state &&
-    deepEqual(handoffInputs, laneInputs(router, router.latestLocation)) &&
-    router._committed === committedMatches &&
-    committedMatches.length &&
-    !controller.signal.aborted
+  const claim = () => {
+    const historyLocation = router.history.location
+    return needsClientLoad &&
+      !router._tx &&
+      historyLocation.href === handoffHistoryHref &&
+      historyLocation.state === handoffHistoryState &&
+      router._committed === committedMatches &&
+      committedMatches.length &&
+      !controller.signal.aborted
       ? controller
       : undefined
+  }
   const handoff: NonNullable<AnyRouter['_handoff']> = [
     claim,
     (matches) => {
       if (router._handoff !== handoff) {
         return
       }
+      // `finish` is single-use. Consume the slot before validating or moving
+      // resources so reentrant work cannot claim the same handoff.
+      router._handoff = undefined
       const prefix = committedMatches.length
       if (
         !matches ||
         !claim() ||
         committedMatches.some((match, index) => match.id !== matches[index]?.id)
       ) {
-        router._handoff = undefined
         controller.abort()
         return
       }
@@ -2666,8 +2617,7 @@ export async function hydrate(router: AnyRouter): Promise<void> {
       if (handoffAssetEnd !== undefined) {
         for (let index = prefix; index < handoffAssetEnd; index++) {
           if (candidates[index]?.id !== matches[index]?.id) {
-            handoffAssetEnd =
-              index > (pendingBoundary ?? -1) + 1 ? index : undefined
+            handoffAssetEnd = index > pendingBoundary! + 1 ? index : undefined
             break
           }
         }