one 1.10.6 → 1.11.0

package/src/createHandleRequest.ts

@@ -13,6 +13,7 @@ export type RequestHandlers = {
   handlePage?: (props: RequestHandlerProps) => Promise<any>
   handleLoader?: (props: RequestHandlerProps) => Promise<any>
   handleAPI?: (props: RequestHandlerProps) => Promise<any>
+  handleStaticFile?: (path: string) => Promise<Response | null>
   loadMiddleware?: (route: RouteNode) => Promise<any>
 }
 
@@ -158,6 +159,10 @@ export async function resolveLoaderRoute(
     console.info(`[one] 📦 loader ${url.pathname} → ${route.file}`)
   }
 
+  const isNativeRequest =
+    url.searchParams.get('platform') === 'ios' ||
+    url.searchParams.get('platform') === 'android'
+
   const response = await runMiddlewares(handlers, request, route, async () => {
     return await resolveResponse(async () => {
       const headers = new Headers()
@@ -176,7 +181,11 @@ export async function resolveLoaderRoute(
           },
         })
 
-        return new Response(loaderResponse, {
+        // native needs CJS format for eval()
+        const body =
+          isNativeRequest && loaderResponse ? toCjsLoader(loaderResponse) : loaderResponse
+
+        return new Response(body, {
           headers,
         })
       } catch (err) {
@@ -202,7 +211,10 @@ export async function resolveLoaderRoute(
     if (location) {
       const redirectUrl = new URL(location, url.origin)
       const redirectPath = redirectUrl.pathname + redirectUrl.search + redirectUrl.hash
-      const body = `export function loader(){return{__oneRedirect:${JSON.stringify(redirectPath)},__oneRedirectStatus:${response.status}}}`
+      const data = `{__oneRedirect:${JSON.stringify(redirectPath)},__oneRedirectStatus:${response.status}}`
+      const body = isNativeRequest
+        ? `exports.loader=function(){return ${data}}`
+        : `export function loader(){return${data}}`
       return new Response(body, {
         headers: { 'Content-Type': 'text/javascript' },
       })
@@ -212,7 +224,10 @@ export async function resolveLoaderRoute(
   // transform auth error responses (401/403) into js modules so the client
   // gets a clean error signal instead of a parse failure
   if (response.status === 401 || response.status === 403) {
-    const body = `export function loader(){return{__oneError:${response.status},__oneErrorMessage:${JSON.stringify(response.statusText || 'Unauthorized')}}}`
+    const data = `{__oneError:${response.status},__oneErrorMessage:${JSON.stringify(response.statusText || 'Unauthorized')}}`
+    const body = isNativeRequest
+      ? `exports.loader=function(){return ${data}}`
+      : `export function loader(){return${data}}`
     return new Response(body, {
       headers: { 'Content-Type': 'text/javascript' },
     })
@@ -221,6 +236,27 @@ export async function resolveLoaderRoute(
   return response
 }
 
+/**
+ * convert an ESM loader response to CJS for native eval().
+ * extracts the JSON data from `export function loader() { return {...} }`
+ * and wraps it as `exports.loader = function() { return {...} }`
+ */
+function toCjsLoader(esmCode: string): string {
+  // already CJS (dev plugin pre-converts for native)
+  if (esmCode.startsWith('exports.')) {
+    return esmCode
+  }
+  // match: export function loader() { return DATA }
+  const match = esmCode.match(
+    /export\s+function\s+loader\s*\(\)\s*\{\s*return\s+([\s\S]+)\s*\}/
+  )
+  if (match) {
+    return `exports.loader=function(){return ${match[1]}}`
+  }
+  // fallback: wrap the whole thing
+  return `exports.loader=function(){return {}}`
+}
+
 export async function resolvePageRoute(
   handlers: RequestHandlers,
   request: Request,
@@ -233,22 +269,24 @@ export async function resolvePageRoute(
     console.info(`[one] 📄 page ${pathname} → ${route.file} (${route.type})`)
   }
 
+  const loaderProps = {
+    path: pathname,
+    search: search,
+    request: route.type === 'ssr' ? request : undefined,
+    params: getLoaderParams(url, route),
+  }
+
+  // flatten the async chain for SSR: skip runMiddlewares wrapper when no middlewares
+  if (!route.middlewares?.length) {
+    return resolveResponse(() => {
+      return handlers.handlePage!({ request, route, url, loaderProps })
+    })
+  }
+
   return resolveResponse(async () => {
-    const resolved = await runMiddlewares(handlers, request, route, async () => {
-      return await handlers.handlePage!({
-        request,
-        route,
-        url,
-        loaderProps: {
-          path: pathname,
-          search: search,
-          // Ensure SSR loaders receive the original request
-          request: route.type === 'ssr' ? request : undefined,
-          params: getLoaderParams(url, route),
-        },
-      })
+    return await runMiddlewares(handlers, request, route, async () => {
+      return await handlers.handlePage!({ request, route, url, loaderProps })
     })
-    return resolved
   })
 }
 
@@ -338,6 +376,22 @@ export function createHandleRequest(
         const isClientRequestingNewRoute = pathname.endsWith(LOADER_JS_POSTFIX_UNCACHED)
 
         if (isClientRequestingNewRoute) {
+          const platformParam = url.searchParams.get('platform')
+          const isNativePlatform =
+            platformParam === 'ios' ||
+            platformParam === 'android' ||
+            platformParam === 'native'
+
+          // for native requests, try serving the pre-built .native.js static file first
+          // (SSG/SPA routes generate standalone CJS loaders at build time)
+          if (isNativePlatform && handlers.handleStaticFile) {
+            const nativeLoaderPath = pathname.replace(/\.js$/, '.native.js')
+            const staticResponse = await handlers.handleStaticFile(nativeLoaderPath)
+            if (staticResponse) {
+              return staticResponse
+            }
+          }
+
           const originalUrl = getPathFromLoaderPath(pathname)
 
           for (const route of compiledManifest.pageRoutes) {
@@ -358,7 +412,10 @@ export function createHandleRequest(
           }
 
           // no matching route - return empty module so client handles gracefully
-          return new Response('export {}', {
+          const emptyBody = isNativePlatform
+            ? 'exports.loader=function(){return{}}'
+            : 'export {}'
+          return new Response(emptyBody, {
             headers: { 'Content-Type': 'text/javascript' },
           })
         }

package/src/daemon/tui.ts

@@ -49,7 +49,7 @@ interface TUIState {
   simEndX: number
   serverStartX: number
   rowStartY: number
-  popup: { message: string; timeout: NodeJS.Timeout } | null
+  popup: { message: string; timeout: ReturnType<typeof setTimeout> } | null
 }
 
 const CABLE_COLORS = [
@@ -72,8 +72,8 @@ const ansi = {
 
 let tuiState: TUIState | null = null
 let daemonState: DaemonState | null = null
-let refreshInterval: NodeJS.Timeout | null = null
-let physicsInterval: NodeJS.Timeout | null = null
+let refreshInterval: ReturnType<typeof setInterval> | null = null
+let physicsInterval: ReturnType<typeof setInterval> | null = null
 let stdinListener: ((key: Buffer) => void) | null = null
 let resizeListener: (() => void) | null = null
 

package/src/fork/NavigationContainer.tsx

@@ -53,6 +53,9 @@ declare global {
 
 globalThis.REACT_NAVIGATION_DEVTOOLS = new WeakMap()
 
+// @modified - SSR-optimized container (bypasses BaseNavigationContainer's 32+ hooks)
+import { SSRNavigationContainer } from './SSRNavigationContainer'
+
 type Props<ParamList extends {}> = NavigationContainerProps & {
   direction?: LocaleDirection
   linking?: LinkingOptions<ParamList>
@@ -77,18 +80,42 @@ type Props<ParamList extends {}> = NavigationContainerProps & {
  * @param props.ref Ref object which refers to the navigation object containing helper methods.
  */
 function NavigationContainerInner(
-  {
-    direction = I18nManager.getConstants().isRTL ? 'rtl' : 'ltr',
-    theme = DefaultTheme,
-    linking,
-    fallback = null,
-    documentTitle,
-    onReady,
-    onStateChange,
-    ...rest
-  }: Props<ParamListBase>,
+  props: Props<ParamListBase>,
   ref?: React.Ref<NavigationContainerRef<ParamListBase> | null>
 ) {
+  // @modified - SSR fast path: bypass BaseNavigationContainer entirely
+  // BaseNavigationContainer has 32+ hooks and 7 providers that are all
+  // unnecessary on SSR (event emitters, child listeners, state sync, etc.)
+  // we provide only the minimal contexts that child navigators read
+  // @modified - SSR fast path: bypass BaseNavigationContainer entirely
+  // eliminates 32+ hooks and reduces 8 providers to 4
+  if (typeof window === 'undefined') {
+    const { theme = DefaultTheme, initialState, linking, children } = props
+    return (
+      <SSRNavigationContainer initialState={initialState} theme={theme} linking={linking}>
+        {children}
+      </SSRNavigationContainer>
+    )
+  }
+
+  return <NavigationContainerClientInner {...props} forwardedRef={ref} />
+}
+
+// @modified - full client NavigationContainer with all hooks and providers
+function NavigationContainerClientInner({
+  forwardedRef,
+  direction = I18nManager.getConstants().isRTL ? 'rtl' : 'ltr',
+  theme = DefaultTheme,
+  linking,
+  fallback = null,
+  documentTitle,
+  onReady,
+  onStateChange,
+  ...rest
+}: Props<ParamListBase> & {
+  forwardedRef?: React.Ref<NavigationContainerRef<ParamListBase> | null>
+}) {
+  const ref = forwardedRef
   const isLinkingEnabled = linking ? linking.enabled !== false : false
 
   if (linking?.config) {
@@ -120,7 +147,6 @@ function NavigationContainerInner(
   )
 
   const onReadyForLinkingHandling = useLatestCallback(() => {
-    // If the screen path matches lastUnhandledLink, we do not track it
     const path = refContainer.current?.getCurrentRoute()?.path
     setLastUnhandledLink((previousLastUnhandledLink) => {
       if (previousLastUnhandledLink === path) {
@@ -133,7 +159,6 @@ function NavigationContainerInner(
 
   const onStateChangeForLinkingHandling = useLatestCallback(
     (state: Readonly<NavigationState> | undefined) => {
-      // If the screen path matches lastUnhandledLink, we do not track it
       const path = refContainer.current?.getCurrentRoute()?.path
       setLastUnhandledLink((previousLastUnhandledLink) => {
         if (previousLastUnhandledLink === path) {
@@ -144,8 +169,7 @@ function NavigationContainerInner(
       onStateChange?.(state)
     }
   )
-  // Add additional linking related info to the ref
-  // This will be used by the devtools
+
   React.useEffect(() => {
     if (refContainer.current) {
       // @ts-ignore - Type differs between react-navigation versions in monorepo
@@ -179,8 +203,6 @@ function NavigationContainerInner(
   const isLinkingReady = rest.initialState != null || !isLinkingEnabled || isResolved
 
   if (!isLinkingReady) {
-    // This is temporary until we have Suspense for data-fetching
-    // Then the fallback will be handled by a parent `Suspense` component
     return <ThemeProvider value={theme}>{fallback}</ThemeProvider>
   }
 

package/src/fork/SSRNavigationContainer.tsx

@@ -0,0 +1,94 @@
+/**
+ * SSR-optimized replacement for BaseNavigationContainer.
+ * Provides only the 4 contexts that child navigators need during SSR render,
+ * with static/no-op values. Eliminates 32+ hooks and reduces 8 providers to 4.
+ *
+ * Requires @react-navigation/core package.json exports to include internal context paths.
+ * See postinstall patch in the repo.
+ */
+
+// @ts-ignore internal module (exports patched at install time)
+import { NavigationBuilderContext } from '@react-navigation/core/lib/module/NavigationBuilderContext'
+// @ts-ignore internal module
+import { NavigationStateContext } from '@react-navigation/core/lib/module/NavigationStateContext'
+// @ts-ignore internal module
+import { SingleNavigatorContext } from '@react-navigation/core/lib/module/EnsureSingleNavigator'
+import { ThemeProvider } from '@react-navigation/core'
+import { LinkingContext } from '@react-navigation/native'
+import * as React from 'react'
+
+const noop = () => {}
+
+// minimal linking context for SSR — tabs needs .options to resolve triggers
+const SSR_LINKING_CTX = { options: undefined as any }
+
+// static context values — never change, zero allocations per render
+const SSR_BUILDER_CTX = {
+  onDispatchAction: noop,
+  onOptionsChange: noop,
+  // must execute callback immediately — useNavigationBuilder calls this during render
+  scheduleUpdate: (cb: () => void) => cb(),
+  flushUpdates: noop,
+  stackRef: { current: undefined },
+}
+
+const SSR_SINGLE_NAV_CTX = {
+  register: noop,
+  unregister: noop,
+}
+
+const getPartialState = (state: any): any => {
+  if (!state) return undefined
+  const { key, routeNames, ...partial } = state
+  return {
+    ...partial,
+    stale: true as const,
+    routes: state.routes.map((route: any) =>
+      route.state ? { ...route, state: getPartialState(route.state) } : route
+    ),
+  }
+}
+
+// cache by initialState reference
+let _cachedState: any = null
+let _cachedCtx: any = null
+
+function getStateContext(initialState: any) {
+  if (_cachedState === initialState && _cachedCtx) return _cachedCtx
+  const partial = getPartialState(initialState)
+  _cachedCtx = {
+    state: partial,
+    getKey: () => undefined as string | undefined,
+    setKey: noop,
+    getState: () => partial,
+    setState: noop,
+    getIsInitial: () => true,
+  }
+  _cachedState = initialState
+  return _cachedCtx
+}
+
+export function SSRNavigationContainer({
+  initialState,
+  theme,
+  linking,
+  children,
+}: {
+  initialState: any
+  theme: any
+  linking?: any
+  children: React.ReactNode
+}) {
+  const linkingCtx = linking ? { options: linking } : SSR_LINKING_CTX
+  return (
+    <LinkingContext.Provider value={linkingCtx}>
+      <NavigationBuilderContext.Provider value={SSR_BUILDER_CTX}>
+        <NavigationStateContext.Provider value={getStateContext(initialState)}>
+          <SingleNavigatorContext.Provider value={SSR_SINGLE_NAV_CTX}>
+            <ThemeProvider value={theme}>{children}</ThemeProvider>
+          </SingleNavigatorContext.Provider>
+        </NavigationStateContext.Provider>
+      </NavigationBuilderContext.Provider>
+    </LinkingContext.Provider>
+  )
+}

package/src/fork/getPathFromState.ts

@@ -22,6 +22,12 @@ import type { NavigationState, PartialState, Route } from '@react-navigation/rou
 import type { PathConfig, PathConfigMap } from '@react-navigation/core' // @modified: import from package instead of relative code
 import { validatePathConfig } from './validatePathConfig'
 
+// @modified - start: use constants for internal navigation param names to avoid magic strings
+const NAV_PARAM_SCREEN = 'screen'
+const NAV_PARAM_PARAMS = 'params'
+const NAV_PARAM_KEY = 'key'
+// @modified - end
+
 type Options<ParamList extends {}> = {
   path?: string
   initialRouteName?: string
@@ -175,7 +181,11 @@ export function getPathDataFromState<ParamList extends {}>(
           Object.entries(route.params!).flatMap(([key, value]) => {
             // Filter out internal navigation params that shouldn't appear in URL
             // 'key' is our deterministic route key used for React reconciliation
-            if (key === 'screen' || key === 'params' || key === 'key') {
+            if (
+              key === NAV_PARAM_SCREEN ||
+              key === NAV_PARAM_PARAMS ||
+              key === NAV_PARAM_KEY
+            ) {
               return []
             }
 
@@ -238,8 +248,8 @@ export function getPathDataFromState<ParamList extends {}>(
         // We can get around this by providing a fake state
         const screens = currentOptions[route.name].screens
         const screen =
-          route.params && 'screen' in route.params
-            ? route.params.screen?.toString()
+          route.params && NAV_PARAM_SCREEN in route.params
+            ? route.params[NAV_PARAM_SCREEN]?.toString()
             : screens
               ? Object.keys(screens)[0]
               : undefined
@@ -249,7 +259,7 @@ export function getPathDataFromState<ParamList extends {}>(
             ...screens[screen],
             name: screen,
             key: screen,
-            params: (route.params as any)?.params,
+            params: (route.params as any)?.[NAV_PARAM_PARAMS],
           }
           currentOptions = screens
         } else {
@@ -330,7 +340,7 @@ export function getPathDataFromState<ParamList extends {}>(
     // @modified - end
 
     if (!focusedParams) {
-      focusedParams = focusedRoute.params
+      focusedParams = { ...focusedRoute.params }
     }
 
     if (route.state) {

package/src/fork/getStateFromPath-mods.ts

@@ -285,7 +285,7 @@ export function getRouteConfigSorter(previousSegments: string[] = []) {
 
 export function formatRegexPattern(it: string): string {
   // Allow spaces in file path names.
-  it = it.replace(' ', '%20')
+  it = it.replace(/ /g, '%20')
 
   if (it.startsWith(':')) {
     // TODO: Remove unused match group

package/src/fork/useLinking.native.ts

@@ -76,20 +76,22 @@ export function useLinking(
       return undefined
     }
 
-    if (enabled !== false && linkingHandlers.length) {
-      console.error(
-        [
-          'Looks like you have configured linking in multiple places. This is likely an error since deep links should only be handled in one place to avoid conflicts. Make sure that:',
-          "- You don't have multiple NavigationContainers in the app each with 'linking' enabled",
-          '- Only a single instance of the root component is rendered',
-          Platform.OS === 'android'
-            ? "- You have set 'android:launchMode=singleTask' in the '<activity />' section of the 'AndroidManifest.xml' file to avoid launching multiple instances"
-            : '',
-        ]
-          .join('\n')
-          .trim()
-      )
+    // @modified - start: reduce spurious warnings on android where activity recreation
+    // causes remounts, and only warn when there are truly multiple handlers
+    if (enabled !== false && linkingHandlers.length && Platform.OS !== 'android') {
+      if (linkingHandlers.length > 1) {
+        console.error(
+          [
+            'Looks like you have configured linking in multiple places. This is likely an error since deep links should only be handled in one place to avoid conflicts. Make sure that:',
+            "- You don't have multiple NavigationContainers in the app each with 'linking' enabled",
+            '- Only a single instance of the root component is rendered',
+          ]
+            .join('\n')
+            .trim()
+        )
+      }
     }
+    // @modified - end
 
     const handler = Symbol()
 

package/src/fork/useLinking.ts

@@ -107,6 +107,25 @@ export function useLinking(
   }: Options,
   onUnhandledLinking: (lastUnhandledLining: string | undefined) => void
 ) {
+  // @modified - SSR fast path: skip all client-only linking logic
+  // on the server, initialState is already computed and passed as a prop
+  // to NavigationContainer, so getInitialState result is never used.
+  // returning a no-op avoids redundant getStateFromPath per-request.
+  if (typeof window === 'undefined') {
+    const getInitialState = React.useCallback(() => {
+      return {
+        then(fn?: (state: ResultState | undefined) => void) {
+          return Promise.resolve(fn ? fn(undefined) : undefined)
+        },
+        catch() {
+          return this
+        },
+      } as PromiseLike<ResultState | undefined>
+    }, [])
+
+    return { getInitialState }
+  }
+
   const independent = useNavigationIndependentTree()
 
   React.useEffect(() => {
@@ -214,7 +233,9 @@ export function useLinking(
       const location =
         server?.location ?? (typeof window !== 'undefined' ? window.location : undefined)
 
-      let path = location ? location.pathname + location.search : undefined
+      let path = location
+        ? location.pathname + location.search + (location.hash ?? '')
+        : undefined
 
       // Check history.state for temp location (client-only)
       if (location && typeof window !== 'undefined') {

package/src/getReactNavigationConfig.ts

@@ -98,6 +98,9 @@ export function getReactNavigationConfig(
   initialRouteName?: string
   screens: Record<string, Screen>
 } {
+  if (!routes) {
+    return { screens: {} }
+  }
   return {
     initialRouteName: routes.initialRouteName,
     screens: getReactNavigationScreensConfig(routes.children, metaOnly),

package/src/index.ts

@@ -147,6 +147,7 @@ export {
 } from './useServerHeadInsertion'
 export { isResponse } from './utils/isResponse'
 export { redirect } from './utils/redirect'
+export { removeParams } from './utils/removeParams'
 export { watchFile } from './utils/watchFile'
 export { ErrorBoundary } from './views/ErrorBoundary'
 export type { ErrorBoundaryProps, ErrorRouteInfo } from './views/Try'

package/src/interfaces/router.ts

@@ -210,12 +210,11 @@ export namespace OneRouter {
 
   /**
    * Returns the search parameters for a route.
+   * Static routes return UnknownOutputParams to allow extra query params.
    */
   export type SearchParams<T extends AllRoutes = never> = T extends DynamicRouteTemplate
     ? OutputRouteParams<T>
-    : T extends StaticRoutes
-      ? never
-      : UnknownOutputParams
+    : UnknownOutputParams
 
   /*********
    * Href  *

package/src/layouts/stack-utils/StackScreen.tsx

@@ -39,12 +39,59 @@ export function StackScreen({ children, options, ...rest }: StackScreenProps) {
   return <Screen {...rest} options={updatedOptions} />
 }
 
+const VALID_PRESENTATIONS = [
+  'card',
+  'modal',
+  'transparentModal',
+  'containedModal',
+  'containedTransparentModal',
+  'fullScreenModal',
+  'formSheet',
+  'pageSheet',
+] as const
+
+// validates presentation value in dev to prevent native crashes from invalid values
+export function validateStackPresentation(
+  options: NativeStackNavigationOptions
+): NativeStackNavigationOptions
+export function validateStackPresentation<
+  F extends (...args: never[]) => NativeStackNavigationOptions,
+>(options: F): F
+export function validateStackPresentation(
+  options:
+    | NativeStackNavigationOptions
+    | ((...args: never[]) => NativeStackNavigationOptions)
+): ((...args: never[]) => NativeStackNavigationOptions) | NativeStackNavigationOptions {
+  if (typeof options === 'function') {
+    return (...args: never[]) => {
+      const resolved = options(...args)
+      validateStackPresentation(resolved)
+      return resolved
+    }
+  }
+
+  if (process.env.NODE_ENV !== 'production') {
+    const presentation = options.presentation
+    if (
+      presentation &&
+      !VALID_PRESENTATIONS.includes(presentation as (typeof VALID_PRESENTATIONS)[number])
+    ) {
+      console.warn(
+        `Invalid presentation value "${presentation}" passed to Stack.Screen. Valid values are: ${VALID_PRESENTATIONS.map((v) => `"${v}"`).join(', ')}.`
+      )
+    }
+  }
+  return options
+}
+
 export function appendScreenStackPropsToOptions(
   options: NativeStackNavigationOptions,
   props: StackScreenProps
 ): NativeStackNavigationOptions {
   let updatedOptions = { ...options, ...props.options }
 
+  validateStackPresentation(updatedOptions)
+
   function appendChildOptions(
     child: React.ReactElement,
     options: NativeStackNavigationOptions

package/src/layouts/stack-utils/index.tsx

@@ -41,5 +41,6 @@ export {
 export {
   StackScreen,
   appendScreenStackPropsToOptions,
+  validateStackPresentation,
   type StackScreenProps,
 } from './StackScreen'

package/src/metro-config/getViteMetroPluginOptions.ts

@@ -213,6 +213,8 @@ export function getViteMetroPluginOptions({
             })(),
           },
         ],
+        // inline ONE_SERVER_URL so native prod bundles know where to fetch loaders
+        'one/babel-plugin-inline-one-server-url',
       ],
     },
   }

package/src/router/findRouteNode.ts

@@ -8,7 +8,7 @@ export function findRouteNodeFromState(
   state: { routes: Array<{ name: string; state?: any }> } | undefined,
   rootNode: RouteNode | null
 ): RouteNode | null {
-  if (!state || !rootNode) {
+  if (!state || !state.routes || !rootNode) {
     return null
   }
 
@@ -65,7 +65,7 @@ export function extractParamsFromState(
     | { routes: Array<{ name: string; params?: Record<string, any>; state?: any }> }
     | undefined
 ): Record<string, string | string[]> {
-  if (!state) {
+  if (!state || !state.routes) {
     return {}
   }
 
@@ -135,7 +135,7 @@ export function findAllRouteNodesFromState(
   state: { routes: Array<{ name: string; state?: any }> } | undefined,
   rootNode: RouteNode | null
 ): RouteNode[] {
-  if (!state || !rootNode) {
+  if (!state || !state.routes || !rootNode) {
     return []
   }
 
@@ -147,7 +147,7 @@ export function findAllRouteNodesFromState(
       | undefined,
     parentNode: RouteNode | null
   ) {
-    if (!currentState || !parentNode) {
+    if (!currentState || !currentState.routes || !parentNode) {
       return
     }
 

package/src/router/isIndexPath.ts

@@ -3,6 +3,10 @@ import type { State } from '../fork/getPathFromState'
 type RouteLikeTree = { name: string; state?: { routes?: RouteLikeTree[] } }
 
 export function isIndexPath(state: State) {
+  if (!state.routes) {
+    return false
+  }
+
   const route = getActualLastRoute(state.routes[state.index ?? state.routes.length - 1])
 
   if (route.state) {