one 1.2.47 → 1.2.49

package/src/metro-config/getViteMetroPluginOptions.ts

@@ -165,30 +165,28 @@ export function getViteMetroPluginOptions({
         [
           'babel-plugin-module-resolver',
           {
-            alias: {
-              // "vite-tsconfig-paths" for Metro
-              ...Object.fromEntries(
-                Object.entries(tsconfigPathsConfigLoadResult.paths).map(([k, v]) => {
-                  const key = (() => {
-                    if (k.endsWith('/*')) {
-                      return k.replace(/\/\*$/, '')
-                    }
-
-                    // If the key does not end with "/*", only alias exact matches.
-                    // Ref: https://www.npmjs.com/package/babel-plugin-module-resolver/v/3.0.0#regular-expression-alias
-                    return `${k}$`
-                  })()
-
-                  let value = v[0].replace(/\/\*$/, '')
-
-                  if (!value.startsWith('./')) {
-                    value = `./${value}`
+            // "vite-tsconfig-paths" for Metro
+            alias: Object.fromEntries(
+              Object.entries(tsconfigPathsConfigLoadResult.paths).map(([k, v]) => {
+                const key = (() => {
+                  if (k.endsWith('/*')) {
+                    return k.replace(/\/\*$/, '')
                   }
 
-                  return [key, value]
-                })
-              ),
-            },
+                  // If the key does not end with "/*", only alias exact matches.
+                  // Ref: https://www.npmjs.com/package/babel-plugin-module-resolver/v/3.0.0#regular-expression-alias
+                  return `${k}$`
+                })()
+
+                let value = v[0].replace(/\/\*$/, '')
+
+                if (!value.startsWith('./')) {
+                  value = `./${value}`
+                }
+
+                return [key, value]
+              })
+            ),
           },
         ],
         [

package/src/router/Route.tsx

@@ -46,7 +46,9 @@ export type RouteNode = {
   middlewares?: RouteNode[]
 }
 
-export const RouteParamsContext = createContext<Record<string, string | undefined> | undefined>({})
+export const RouteParamsContext = createContext<
+  Record<string, string | undefined> | undefined
+>({})
 
 const CurrentRouteContext = React.createContext<RouteNode | null>(null)
 

package/src/router/RouteInfoContext.tsx

@@ -56,7 +56,9 @@ export function RouteInfoContextProvider({ children }: { children: React.ReactNo
   currentStateRef.current = currentState
 
   return (
-    <RouteInfoContext.Provider value={currentState ? lazilyCalculatedRouteInfo.current : undefined}>
+    <RouteInfoContext.Provider
+      value={currentState ? lazilyCalculatedRouteInfo.current : undefined}
+    >
       {children}
     </RouteInfoContext.Provider>
   )

package/src/router/filterRootHTML.ts

@@ -70,7 +70,11 @@ export function filterRootHTML(el: React.ReactNode): FoundRootHTML {
       ) {
         // filter out HTML elements on native (e.g. <div>, <meta>)
         // preserve children so <div><Slot/></div> renders <Slot/> instead of nothing
-        if (element.props && typeof element.props === 'object' && 'children' in element.props) {
+        if (
+          element.props &&
+          typeof element.props === 'object' &&
+          'children' in element.props
+        ) {
           return traverse(element.props.children as React.ReactNode)
         }
         return null

package/src/router/getLinkingConfig.ts

@@ -54,7 +54,10 @@ export function getLinkingConfig(routes: RouteNode, metaOnly = true): OneLinking
 export const stateCache = new Map<string, any>()
 
 /** We can reduce work by memoizing the state by the pathname. This only works because the options (linking config) theoretically never change.  */
-function getStateFromPathMemoized(path: string, options: Parameters<typeof getStateFromPath>[1]) {
+function getStateFromPathMemoized(
+  path: string,
+  options: Parameters<typeof getStateFromPath>[1]
+) {
   const cached = stateCache.get(path)
   if (cached) {
     return cached

package/src/router/getNormalizedStatePath.tsx

@@ -24,7 +24,10 @@ export function getNormalizedStatePath(
   const [pathname] = statePath.split('?')
   return {
     // Strip empty path at the start
-    segments: stripBaseUrl(pathname, baseUrl).split('/').filter(Boolean).map(decodeURIComponent),
+    segments: stripBaseUrl(pathname, baseUrl)
+      .split('/')
+      .filter(Boolean)
+      .map(decodeURIComponent),
     // TODO: This is not efficient, we should generate based on the state instead
     // of converting to string then back to object
     params: Object.entries(params).reduce((prev, [key, value]) => {

package/src/router/getRoutes.ts

@@ -350,10 +350,14 @@ function getFileMeta(key: string, options: Options) {
   const isLayout = filenameWithoutExtensions.startsWith('_layout')
   const isMiddleware = filenameWithoutExtensions.startsWith('_middleware')
 
-  const [_fullname, renderModeFound] = filename.match(/\+(api|ssg|ssr|spa)\.(\w+\.)?[jt]sx?$/) || []
+  const [_fullname, renderModeFound] =
+    filename.match(/\+(api|ssg|ssr|spa)\.(\w+\.)?[jt]sx?$/) || []
   const renderMode = renderModeFound as 'api' | One.RouteRenderMode | undefined
 
-  if (filenameWithoutExtensions.startsWith('(') && filenameWithoutExtensions.endsWith(')')) {
+  if (
+    filenameWithoutExtensions.startsWith('(') &&
+    filenameWithoutExtensions.endsWith(')')
+  ) {
     throw new Error(`Invalid route ./${key}. Routes cannot end with '(group)' syntax`)
   }
 
@@ -440,7 +444,10 @@ export function getIgnoreList(options?: Options) {
  *
  * /(a,b)/(c,d)/e.tsx => new Set(['a/c/e.tsx', 'a/d/e.tsx', 'b/c/e.tsx', 'b/d/e.tsx'])
  */
-export function extrapolateGroups(key: string, keys: Set<string> = new Set()): Set<string> {
+export function extrapolateGroups(
+  key: string,
+  keys: Set<string> = new Set()
+): Set<string> {
   const match = matchArrayGroupName(key)
 
   if (!match) {
@@ -451,7 +458,9 @@ export function extrapolateGroups(key: string, keys: Set<string> = new Set()): S
   const groupsSet = new Set(groups)
 
   if (groupsSet.size !== groups.length) {
-    throw new Error(`Array syntax cannot contain duplicate group name "${groups}" in "${key}".`)
+    throw new Error(
+      `Array syntax cannot contain duplicate group name "${groups}" in "${key}".`
+    )
   }
 
   if (groups.length === 1) {

package/src/router/linkingConfig.ts

@@ -1,5 +1,8 @@
 import type { OneRouter } from '../interfaces/router'
-import { getLinkingConfig as createLinkingConfig, type OneLinkingOptions } from './getLinkingConfig'
+import {
+  getLinkingConfig as createLinkingConfig,
+  type OneLinkingOptions,
+} from './getLinkingConfig'
 import type { RouteNode } from './Route'
 
 let linkingConfig: OneLinkingOptions | undefined

package/src/router/matchers.test.ts

@@ -110,11 +110,15 @@ describe(matchArrayGroupName, () => {
     expect(matchArrayGroupName('leading/(foo,bar)/(fruit,apple)')).toEqual('foo,bar')
     expect(matchArrayGroupName('(leading)/(foo,bar)')).toEqual('foo,bar')
     expect(matchArrayGroupName('(leading)/(foo,bar)/trailing)')).toEqual('foo,bar')
-    expect(matchArrayGroupName('(leading)/((foo),(bar))/trailing)')).toEqual('(foo),(bar)')
+    expect(matchArrayGroupName('(leading)/((foo),(bar))/trailing)')).toEqual(
+      '(foo),(bar)'
+    )
   })
   it.skip(`should only match the first group with array group syntax`, () => {
     expect(matchArrayGroupName('(leading)/(foo,bar)/(fruit,apple)')).toEqual('foo,bar')
-    expect(matchArrayGroupName('(leading)/((foo),bar)/(fruit,apple)')).toEqual('(foo),bar')
+    expect(matchArrayGroupName('(leading)/((foo),bar)/(fruit,apple)')).toEqual(
+      '(foo),bar'
+    )
     expect(matchArrayGroupName('(leading)/(foo,bar)/((fruit),apple)')).toEqual('foo,bar')
   })
 })

package/src/router/matchers.ts

@@ -28,7 +28,7 @@ export function matchDeepDynamicRouteName(name: string): string | undefined {
 
 /** Test `/` -> `page` */
 export function testNotFound(name: string): boolean {
-  return /\+not-found$/.test(name)
+  return name.endsWith('+not-found')
 }
 
 /** Match `(page)` -> `page` */

package/src/router/router.ts

@@ -4,7 +4,10 @@
  * the best decision.
  */
 
-import { type NavigationContainerRefWithCurrent, StackActions } from '@react-navigation/native'
+import {
+  type NavigationContainerRefWithCurrent,
+  StackActions,
+} from '@react-navigation/native'
 import * as Linking from 'expo-linking'
 import {
   type ComponentType,
@@ -77,7 +80,9 @@ export function initialize(
       const prefix = indent + (isLast ? '└─ ' : '├─ ')
       const childIndent = indent + (isLast ? '   ' : '│  ')
 
-      const dynamicBadge = node.dynamic ? ` [${node.dynamic.map((d) => d.name).join(', ')}]` : ''
+      const dynamicBadge = node.dynamic
+        ? ` [${node.dynamic.map((d) => d.name).join(', ')}]`
+        : ''
       const typeBadge = node.type !== 'layout' ? ` (${node.type})` : ''
       const routeName = node.route || '/'
 
@@ -360,13 +365,21 @@ function syncStoreRootState() {
 
 export function useStoreRootState() {
   syncStoreRootState()
-  const state = useSyncExternalStore(subscribeToRootState, rootStateSnapshot, rootStateSnapshot)
+  const state = useSyncExternalStore(
+    subscribeToRootState,
+    rootStateSnapshot,
+    rootStateSnapshot
+  )
   return useDeferredValue(state)
 }
 
 export function useStoreRouteInfo() {
   syncStoreRootState()
-  const state = useSyncExternalStore(subscribeToRootState, routeInfoSnapshot, routeInfoSnapshot)
+  const state = useSyncExternalStore(
+    subscribeToRootState,
+    routeInfoSnapshot,
+    routeInfoSnapshot
+  )
   return useDeferredValue(state)
 }
 
@@ -445,7 +458,11 @@ export function preloadRoute(href: string, injectCSS = false): Promise<any> | un
   return preloadingLoader[href]
 }
 
-export async function linkTo(href: string, event?: string, options?: OneRouter.LinkToOptions) {
+export async function linkTo(
+  href: string,
+  event?: string,
+  options?: OneRouter.LinkToOptions
+) {
   if (process.env.ONE_DEBUG_ROUTER) {
     console.info(`[one] 🔗 ${event || 'NAVIGATE'} ${href}`)
   }
@@ -513,7 +530,9 @@ export async function linkTo(href: string, event?: string, options?: OneRouter.L
   const state = linking.getStateFromPath!(href, linking.config)
 
   if (!state || state.routes.length === 0) {
-    console.error('Could not generate a valid navigation state for the given path: ' + href)
+    console.error(
+      'Could not generate a valid navigation state for the given path: ' + href
+    )
     console.error(`linking.config`, linking.config)
     console.error(`routes`, getSortedRoutes())
     return

package/src/router/useNavigation.ts

@@ -44,7 +44,10 @@ export function useNavigation<T = NavigationProp<ReactNavigation.RootParamList>>
   return navigation
 }
 
-export function resolveParentId(contextKey: string, parentId?: string | null): string | null {
+export function resolveParentId(
+  contextKey: string,
+  parentId?: string | null
+): string | null {
   if (!parentId) {
     return null
   }

package/src/router/useScreens.tsx

@@ -7,7 +7,7 @@ import type {
   RouteProp,
   ScreenListeners,
 } from '@react-navigation/native'
-import React, { memo, Suspense, useId } from 'react'
+import React, { memo, Suspense, useEffect, useId, useState } from 'react'
 import { SafeAreaView, ScrollView, Text, TouchableOpacity, View } from 'react-native'
 import { ServerContextScript } from '../server/ServerContextScript'
 import { getPageExport } from '../utils/getPageExport'
@@ -34,17 +34,102 @@ export const { Screen, Group } = createNavigatorFactory({} as any)()
 // so hydration sees identical content without 100KB+ JSON payload.
 const cachedInlineCSSElements: React.ReactNode[] =
   typeof document !== 'undefined'
-    ? Array.from(document.querySelectorAll<HTMLStyleElement>('style[id^="__one_css_"]')).map(
-        (el, i) => (
-          <style
-            key={`inline-css-${i}`}
-            id={el.id}
-            dangerouslySetInnerHTML={{ __html: el.innerHTML }}
-          />
-        )
-      )
+    ? Array.from(
+        document.querySelectorAll<HTMLStyleElement>('style[id^="__one_css_"]')
+      ).map((el, i) => (
+        <style
+          key={`inline-css-${i}`}
+          id={el.id}
+          dangerouslySetInnerHTML={{ __html: el.innerHTML }}
+        />
+      ))
     : []
 
+/**
+ * Separate component for rendering root layouts with HTML.
+ * This is extracted into its own component so React's HMR can properly track changes.
+ * When the LayoutComponent prop changes, React will re-render this component.
+ */
+function RootLayoutRenderer({
+  LayoutComponent,
+  layoutProps,
+  forwardedRef,
+}: {
+  LayoutComponent: React.ComponentType<any>
+  layoutProps: any
+  forwardedRef: any
+}) {
+  // HMR support: force re-render when layout changes (dev only, web only)
+  if (process.env.NODE_ENV === 'development' && process.env.TAMAGUI_TARGET !== 'native') {
+    // eslint-disable-next-line react-hooks/rules-of-hooks
+    const [, setHmrKey] = useState(0)
+    // eslint-disable-next-line react-hooks/rules-of-hooks
+    useEffect(() => {
+      const handler = () => setHmrKey((k) => k + 1)
+      window.addEventListener('one-hmr-update', handler)
+      return () => window.removeEventListener('one-hmr-update', handler)
+    }, [])
+  }
+
+  // Call the layout component to get its output for HTML filtering
+  // @ts-expect-error
+  const out = LayoutComponent(layoutProps, forwardedRef)
+
+  const { children, bodyProps, head, htmlProps } = filterRootHTML(out)
+  const { children: headChildren, ...headProps } = (head?.props || {}) as Record<
+    string,
+    any
+  >
+  const serverContext = useServerContext()
+
+  let finalChildren = children
+
+  if (process.env.TAMAGUI_TARGET === 'native') {
+    // on native we just ignore all html/body/head
+    return finalChildren
+  }
+
+  finalChildren = (
+    <>
+      <head key="head" {...headProps}>
+        <DevHead />
+        <script
+          dangerouslySetInnerHTML={{
+            __html: `globalThis['global'] = globalThis`,
+          }}
+        />
+        {serverContext?.cssContents?.length || serverContext?.cssInlineCount
+          ? // Inline CSS: SSR renders fresh, client uses cached elements from module load
+            serverContext?.cssContents
+            ? serverContext.cssContents.map((content, i) => (
+                <style
+                  key={`inline-css-${i}`}
+                  id={`__one_css_${i}`}
+                  dangerouslySetInnerHTML={{ __html: content }}
+                />
+              ))
+            : cachedInlineCSSElements
+          : serverContext?.css?.map((file) => (
+              <link key={file} rel="stylesheet" href={file} />
+            ))}
+        <ServerContextScript />
+        {headChildren}
+      </head>
+      <body key="body" suppressHydrationWarning {...bodyProps}>
+        <SafeAreaProviderCompat>{finalChildren}</SafeAreaProviderCompat>
+      </body>
+    </>
+  )
+
+  return (
+    // tamagui and libraries can add className on hydration to have ssr safe styling
+    // so supress hydration warnings here
+    <html suppressHydrationWarning lang="en-US" {...htmlProps}>
+      {finalChildren}
+    </html>
+  )
+}
+
 export type ScreenProps<
   TOptions extends Record<string, any> = Record<string, any>,
   State extends NavigationState = NavigationState,
@@ -87,7 +172,9 @@ function getSortedChildren(
   const ordered = order
     .map(({ name, redirect, initialParams, listeners, options, getId }) => {
       if (!entries.length) {
-        console.warn(`[Layout children]: Too many screens defined. Route "${name}" is extraneous.`)
+        console.warn(
+          `[Layout children]: Too many screens defined. Route "${name}" is extraneous.`
+        )
         return null
       }
       const matchIndex = entries.findIndex((child) => child.route === name)
@@ -185,6 +272,21 @@ export function getQualifiedRouteComponent(value: RouteNode) {
   }
 
   const ScreenComponent = React.forwardRef((props: any, ref) => {
+    // HMR support: force re-render when layout files change to get fresh module (dev only, web only)
+    if (
+      process.env.NODE_ENV === 'development' &&
+      process.env.TAMAGUI_TARGET !== 'native'
+    ) {
+      // eslint-disable-next-line react-hooks/rules-of-hooks
+      const [, setHmrKey] = useState(0)
+      // eslint-disable-next-line react-hooks/rules-of-hooks
+      useEffect(() => {
+        const handler = () => setHmrKey((k) => k + 1)
+        window.addEventListener('one-hmr-update', handler)
+        return () => window.removeEventListener('one-hmr-update', handler)
+      }, [])
+    }
+
     const res = value.loadRoute()
     const Component = getPageExport(fromImport(res)) as React.ComponentType<any>
 
@@ -195,59 +297,14 @@ export function getQualifiedRouteComponent(value: RouteNode) {
       console.groupEnd()
     }
 
-    // this is causing HMR to not work on root layout
+    // Root layout with HTML support - use RootLayoutRenderer for proper HMR tracking
     if (props.segment === '') {
-      // @ts-expect-error
-      const out = Component(props, ref)
-
-      const { children, bodyProps, head, htmlProps } = filterRootHTML(out)
-      const { children: headChildren, ...headProps } = (head?.props || {}) as Record<string, any>
-      const serverContext = useServerContext()
-
-      // let finalChildren = <Suspense fallback={null}>{children}</Suspense>
-      let finalChildren = children
-
-      if (process.env.TAMAGUI_TARGET === 'native') {
-        // on native we just ignore all html/body/head
-        return finalChildren
-      }
-
-      finalChildren = (
-        <>
-          <head key="head" {...headProps}>
-            <DevHead />
-            <script
-              dangerouslySetInnerHTML={{
-                __html: `globalThis['global'] = globalThis`,
-              }}
-            />
-            {serverContext?.cssContents?.length || serverContext?.cssInlineCount
-              ? // Inline CSS: SSR renders fresh, client uses cached elements from module load
-                serverContext?.cssContents
-                ? serverContext.cssContents.map((content, i) => (
-                    <style
-                      key={`inline-css-${i}`}
-                      id={`__one_css_${i}`}
-                      dangerouslySetInnerHTML={{ __html: content }}
-                    />
-                  ))
-                : cachedInlineCSSElements
-              : serverContext?.css?.map((file) => <link key={file} rel="stylesheet" href={file} />)}
-            <ServerContextScript />
-            {headChildren}
-          </head>
-          <body key="body" suppressHydrationWarning {...bodyProps}>
-            <SafeAreaProviderCompat>{finalChildren}</SafeAreaProviderCompat>
-          </body>
-        </>
-      )
-
       return (
-        // tamagui and libraries can add className on hydration to have ssr safe styling
-        // so supress hydration warnings here
-        <html suppressHydrationWarning lang="en-US" {...htmlProps}>
-          {finalChildren}
-        </html>
+        <RootLayoutRenderer
+          LayoutComponent={Component}
+          layoutProps={props}
+          forwardedRef={ref}
+        />
       )
     }
 
@@ -264,7 +321,10 @@ export function getQualifiedRouteComponent(value: RouteNode) {
     // i tried a lot of things, but didn't find the root cause, but native needs suspense or
     // else it hits an error about no suspense boundary being set
 
-    if (process.env.TAMAGUI_TARGET === 'native' || process.env.ONE_SUSPEND_ROUTES === '1') {
+    if (
+      process.env.TAMAGUI_TARGET === 'native' ||
+      process.env.ONE_SUSPEND_ROUTES === '1'
+    ) {
       return <Suspense fallback={null}>{children}</Suspense>
     }
     return children
@@ -343,7 +403,10 @@ export function createGetIdForRoute(
   }
 }
 
-function routeToScreen(route: RouteNode, { options, ...props }: Partial<ScreenProps> = {}) {
+function routeToScreen(
+  route: RouteNode,
+  { options, ...props }: Partial<ScreenProps> = {}
+) {
   return (
     <Screen
       // Users can override the screen getId function.

package/src/router/useViteRoutes.tsx

@@ -129,7 +129,8 @@ export async function preloadRouteModules(href: string): Promise<void> {
       (normalizedHref !== '' && routePath === normalizedHref.split('/')[0]) // top-level match
 
     // also check dynamic route patterns like docs/[slug]
-    const isDynamicMatch = routePath.includes('[') && matchDynamicRoute(routePath, normalizedHref)
+    const isDynamicMatch =
+      routePath.includes('[') && matchDynamicRoute(routePath, normalizedHref)
 
     if ((isStaticMatch || isDynamicMatch) && typeof globbed[key] === 'function') {
       promises.push(
@@ -163,6 +164,7 @@ export function globbedRoutesToRouteContext(
 ): One.RouteContext {
   // make it look like webpack context
   const routesSync = {}
+  const routePaths = {} // Store full paths for HMR cache-busting imports
   const promises = {}
   const loadedRoutes = {}
   const clears = {}
@@ -184,11 +186,36 @@ export function globbedRoutesToRouteContext(
       }
     } else {
       routesSync[pathWithoutRelative] = loadRouteFunction
+      routePaths[pathWithoutRelative] = path // Store full path for HMR
     }
   })
 
   const moduleKeys = Object.keys(routesSync)
 
+  // Track HMR version for cache busting
+  let hmrVersion = 0
+
+  // Expose a function to clear the cache for HMR support
+  if (typeof window !== 'undefined') {
+    ;(window as any).__oneRouteCache = {
+      clear: () => {
+        hmrVersion++
+        // Clear all caches
+        Object.keys(loadedRoutes).forEach((key) => {
+          delete loadedRoutes[key]
+        })
+        Object.keys(promises).forEach((key) => {
+          delete promises[key]
+        })
+        // Clear preloaded modules too
+        Object.keys(preloadedModules).forEach((key) => {
+          delete preloadedModules[key]
+        })
+      },
+      getVersion: () => hmrVersion,
+    }
+  }
+
   function resolve(id: string) {
     clearTimeout(clears[id])
 
@@ -209,7 +236,22 @@ export function globbedRoutesToRouteContext(
     }
 
     if (!promises[id]) {
-      promises[id] = routesSync[id]()
+      // In dev mode after HMR, use cache-busting import to get fresh module
+      // Note: we use a block + IIFE to help bundlers fully eliminate the import() call
+      // which Hermes cannot parse even as dead code
+      let importPromise: Promise<any>
+      if (
+        process.env.VITE_PLATFORM !== 'native' &&
+        process.env.NODE_ENV === 'development' &&
+        hmrVersion > 0 &&
+        routePaths[id]
+      ) {
+        importPromise = (0, eval)('imp' + 'ort')(`${routePaths[id]}?t=${Date.now()}`)
+      } else {
+        importPromise = routesSync[id]()
+      }
+
+      promises[id] = importPromise
         .then((val: any) => {
           loadedRoutes[id] = val
           delete promises[id]

package/src/router/utils/getNavigateAction.ts

@@ -47,7 +47,8 @@ export function getNavigateAction(
       !childState ||
       !nextNavigationState ||
       (dynamicMatch &&
-        actionStateRoute.params?.[dynamicMatch.name] !== stateRoute.params?.[dynamicMatch.name])
+        actionStateRoute.params?.[dynamicMatch.name] !==
+          stateRoute.params?.[dynamicMatch.name])
 
     if (didActionAndCurrentStateDiverge) {
       break
@@ -71,7 +72,8 @@ export function getNavigateAction(
     payload.screen = actionStateRoute.name
     payload.params = { ...actionStateRoute.params }
 
-    actionStateRoute = actionStateRoute.state?.routes[actionStateRoute.state?.routes.length - 1]
+    actionStateRoute =
+      actionStateRoute.state?.routes[actionStateRoute.state?.routes.length - 1]
 
     payload.params ??= {}
     payload = payload.params

package/src/server/createRoutesManifest.ts

@@ -25,7 +25,10 @@ function createMockModuleWithContext(map: string[] = []) {
   return contextModule as One.RouteContext
 }
 
-export function createRoutesManifest(paths: string[], options: Options): RoutesManifest | null {
+export function createRoutesManifest(
+  paths: string[],
+  options: Options
+): RoutesManifest | null {
   const routeTree = getRoutes(createMockModuleWithContext(paths), {
     ...options,
     preserveApiRoutes: true,

package/src/server/getServerManifest.ts

@@ -85,7 +85,9 @@ export function getServerManifest(route: RouteNode): OneRouterServerManifestV1 {
   for (const [path, route] of flat) {
     if (pathToRoute[path]) {
       console.warn(`\n[one] ❌ Duplicate routes error`)
-      console.warn(`  Multiple routes at the same path! One route will always win over the other.`)
+      console.warn(
+        `  Multiple routes at the same path! One route will always win over the other.`
+      )
       console.warn(`    path: ${path}`)
       console.warn(`    first route: ${pathToRoute[path].contextKey}`)
       console.warn(`    second route: ${route.contextKey}\n`)
@@ -141,7 +143,10 @@ function getGeneratedNamedRouteRegex(
   }
 }
 
-function getRouteEntry(normalizedRoute: string, node: RouteNode): OneRouterServerManifestV1Route {
+function getRouteEntry(
+  normalizedRoute: string,
+  node: RouteNode
+): OneRouterServerManifestV1Route {
   const result = getPathMeta(normalizedRoute)
   return {
     file: node.contextKey,