one 1.10.6 → 1.11.0

package/src/server/oneServe.ts

@@ -18,18 +18,19 @@ import { getPathFromLoaderPath } from '../utils/cleanUrl'
 import { toAbsolute } from '../utils/toAbsolute'
 import type { One } from '../vite/types'
 import type { RouteInfoCompiled } from './createRoutesManifest'
+import { setSSRLoaderData } from './ssrLoaderData'
 import { getFetchStaticHtml } from './staticHtmlFetcher'
 
 const debugRouter = process.env.ONE_DEBUG_ROUTER
 
-async function readStaticHtml(htmlPath: string): Promise<string | null> {
+async function readStaticHtml(htmlPath: string, outDir = 'dist'): Promise<string | null> {
   const fetchStaticHtml = getFetchStaticHtml()
   if (fetchStaticHtml) {
     const html = await fetchStaticHtml(htmlPath)
     if (html) return html
   }
   try {
-    return await readFile(join('dist/client', htmlPath), 'utf-8')
+    return await readFile(join(`${outDir}/client`, htmlPath), 'utf-8')
   } catch {
     return null
   }
@@ -55,6 +56,7 @@ export async function oneServe(
     lazyRoutes?: LazyRoutes
   }
 ) {
+  const outDir = buildInfo.outDir || 'dist'
   const { resolveAPIRoute, resolveLoaderRoute, resolvePageRoute } =
     await import('../createHandleRequest')
   const { isResponse } = await import('../utils/isResponse')
@@ -115,6 +117,55 @@ export async function oneServe(
 
   const apiCJS = oneOptions.build?.api?.outputFormat === 'cjs'
 
+  // cache resolved loader functions directly (not just modules)
+  const loaderCache = new Map<string, Function | null>()
+  const moduleImportCache = new Map<string, any>()
+
+  // loader coalescing via static loaderCache export
+  // when a route exports loaderCache, concurrent requests with the same key share one execution
+  const loaderCacheFnMap = new Map<string, Function | null>()
+  const pendingLoaderResults = new Map<
+    string,
+    { promise: Promise<any>; expires: number }
+  >()
+
+  // resolve a route module's loader - sync on cache hit, async on cold start
+  function resolveLoaderSync(
+    serverPath: string | undefined,
+    lazyKey: string | undefined
+  ): Function | null | Promise<Function | null> {
+    const cacheKey = lazyKey || serverPath || ''
+    const cached = loaderCache.get(cacheKey)
+    if (cached !== undefined) return cached // sync!
+
+    // cold path - async import
+    return (async () => {
+      const pathToResolve = serverPath || lazyKey || ''
+      const resolvedPath = pathToResolve.includes(`${outDir}/server`)
+        ? pathToResolve
+        : join('./', `${outDir}/server`, pathToResolve)
+
+      let routeExported: any
+      if (moduleImportCache.has(cacheKey)) {
+        routeExported = moduleImportCache.get(cacheKey)
+      } else {
+        routeExported = lazyKey
+          ? options?.lazyRoutes?.pages?.[lazyKey]
+            ? await options.lazyRoutes.pages[lazyKey]()
+            : await import(toAbsolute(resolvedPath))
+          : await import(toAbsolute(serverPath!))
+        moduleImportCache.set(cacheKey, routeExported)
+      }
+
+      const loader = routeExported?.loader || null
+      loaderCache.set(cacheKey, loader)
+      // also cache loaderCache export for coalescing
+      const loaderCacheFn = routeExported?.loaderCache ?? null
+      loaderCacheFnMap.set(cacheKey, loaderCacheFn)
+      return loader
+    })()
+  }
+
   // shared helper to import a route module and run its loader
   async function importAndRunLoader(
     routeId: string,
@@ -126,19 +177,60 @@ export async function oneServe(
       return { loaderData: undefined, routeId }
     }
 
+    // check loaderCache BEFORE resolving the loader (fast path for coalesced requests)
+    const cacheMapKey = lazyKey || serverPath || ''
+    const loaderCacheFn = loaderCacheFnMap.get(cacheMapKey)
+    let coalFullKey: string | undefined
+    let coalTtl = 0
+
+    if (loaderCacheFn) {
+      const cacheResult = loaderCacheFn(loaderProps?.params, loaderProps?.request)
+      const cacheKey = typeof cacheResult === 'string' ? cacheResult : cacheResult?.key
+      coalTtl = typeof cacheResult === 'string' ? 0 : (cacheResult?.ttl ?? 0)
+
+      if (cacheKey != null) {
+        coalFullKey = routeId + '\0' + cacheKey
+        const existing = pendingLoaderResults.get(coalFullKey)
+        // expires=0 means pending or no-TTL (coalesce-only), so !0 is true
+        if (existing && (!existing.expires || Date.now() < existing.expires)) {
+          // coalesce: reuse pending/cached result (never even resolves the loader fn)
+          const loaderData = await existing.promise
+          return { loaderData, routeId }
+        }
+      }
+    }
+
     try {
-      const pathToResolve = serverPath || lazyKey || ''
-      const resolvedPath = pathToResolve.includes('dist/server')
-        ? pathToResolve
-        : join('./', 'dist/server', pathToResolve)
+      const loaderOrPromise = resolveLoaderSync(serverPath, lazyKey)
+      const loader =
+        loaderOrPromise instanceof Promise ? await loaderOrPromise : loaderOrPromise
+      if (!loader) {
+        return { loaderData: undefined, routeId }
+      }
 
-      const routeExported = lazyKey
-        ? options?.lazyRoutes?.pages?.[lazyKey]
-          ? await options.lazyRoutes.pages[lazyKey]()
-          : await import(toAbsolute(resolvedPath))
-        : await import(toAbsolute(serverPath!))
+      // first caller with loaderCache: execute and register for coalescing
+      if (coalFullKey) {
+        const promise = loader(loaderProps)
+        const entry = { promise, expires: 0 }
+        pendingLoaderResults.set(coalFullKey, entry)
+        promise.then(
+          () => {
+            entry.expires = coalTtl > 0 ? Date.now() + coalTtl : 0
+            if (coalTtl <= 0) {
+              Promise.resolve().then(() => pendingLoaderResults.delete(coalFullKey!))
+            }
+          },
+          () => {
+            pendingLoaderResults.delete(coalFullKey!)
+          }
+        )
+
+        const loaderData = await promise
+        return { loaderData, routeId }
+      }
 
-      const loaderData = await routeExported?.loader?.(loaderProps)
+      // no coalescing: run loader directly
+      const loaderData = await loader(loaderProps)
       return { loaderData, routeId }
     } catch (err) {
       if (isResponse(err)) {
@@ -152,25 +244,47 @@ export async function oneServe(
     }
   }
 
-  // Lazy load server entry only when needed for SSR
+  // lazy load server entry - sync on cache hit
   let render: ((props: RenderAppProps) => any) | null = null
-  async function getRender() {
-    if (!render) {
-      // Use lazy import if available (workers), otherwise dynamic import (Node.js)
+  let renderStream: ((props: RenderAppProps) => Promise<ReadableStream>) | null = null
+  let renderLoading: Promise<void> | null = null
+
+  function ensureRenderLoaded(): void | Promise<void> {
+    if (render) return // sync!
+    if (renderLoading) return renderLoading
+    renderLoading = (async () => {
       const entry = options?.lazyRoutes?.serverEntry
         ? await options.lazyRoutes.serverEntry()
         : await import(
             resolve(
               process.cwd(),
-              `${serverOptions.root}/dist/server/_virtual_one-entry.${typeof oneOptions.build?.server === 'object' && oneOptions.build.server.outputFormat === 'cjs' ? 'c' : ''}js`
+              `${serverOptions.root}/${outDir}/server/_virtual_one-entry.${typeof oneOptions.build?.server === 'object' && oneOptions.build.server.outputFormat === 'cjs' ? 'c' : ''}js`
             )
           )
       render = entry.default.render as (props: RenderAppProps) => any
-    }
-    return render
+      renderStream = entry.default.renderStream as
+        | ((props: RenderAppProps) => Promise<ReadableStream>)
+        | null
+    })()
+    return renderLoading
   }
 
+  const clientDir = join(process.cwd(), outDir, 'client')
+
   const requestHandlers: RequestHandlers = {
+    async handleStaticFile(filePath: string) {
+      try {
+        // filePath is like /assets/index_123_vxrn_loader.native.js
+        const fullPath = join(clientDir, filePath)
+        const content = await readFile(fullPath, 'utf-8')
+        return new Response(content, {
+          headers: { 'Content-Type': 'text/javascript' },
+        })
+      } catch {
+        return null
+      }
+    },
+
     async handleAPI({ route }) {
       // Use lazy import if available (workers), otherwise dynamic import (Node.js)
       if (options?.lazyRoutes?.api?.[route.page]) {
@@ -180,7 +294,7 @@ export async function oneServe(
       const fileName = route.page.slice(1).replace(/\[/g, '_').replace(/\]/g, '_')
       const apiFile = join(
         process.cwd(),
-        'dist',
+        outDir,
         'api',
         fileName + (apiCJS ? '.cjs' : '.js')
       )
@@ -196,30 +310,22 @@ export async function oneServe(
     },
 
     async handleLoader({ route, loaderProps }) {
-      // Use lazy import if available (workers), otherwise dynamic import (Node.js)
-      // For workers, look up by routeFile (original file path like "./dynamic/[id]+ssr.tsx")
-      // For Node.js, use route.file which may be loaderServerPath (already includes dist/server)
       const routeFile = (route as any).routeFile || route.file
-      // route.file may already include dist/server if it came from loaderServerPath
-      const serverPath = route.file.includes('dist/server')
+      const serverPath = route.file.includes(`${outDir}/server`)
         ? route.file
-        : join('./', 'dist/server', route.file)
+        : join('./', `${outDir}/server`, route.file)
 
-      let exports
+      let loader: Function | null
       try {
-        exports = options?.lazyRoutes?.pages?.[routeFile]
-          ? await options.lazyRoutes.pages[routeFile]()
-          : await import(toAbsolute(serverPath))
+        const loaderResult = resolveLoaderSync(serverPath, routeFile)
+        loader = loaderResult instanceof Promise ? await loaderResult : loaderResult
       } catch (err) {
-        // module doesn't exist (e.g., dynamic route with slug not in generateStaticParams)
         if ((err as any)?.code === 'ERR_MODULE_NOT_FOUND') {
           return null
         }
         throw err
       }
 
-      const { loader } = exports
-
       if (!loader) {
         return null
       }
@@ -309,7 +415,7 @@ export async function oneServe(
             if (nfHtml) {
               try {
                 const html = await readFile(
-                  join(process.cwd(), 'dist/client', nfHtml),
+                  join(process.cwd(), `${outDir}/client`, nfHtml),
                   'utf-8'
                 )
                 return new Response(html, {
@@ -340,28 +446,55 @@ export async function oneServe(
           // for backwards compat, loaderData is still the page's loader data
           const loaderData = pageResult.loaderData
 
+          // populate per-loader WeakMap so layout useLoader gets correct data
+          for (const layout of layoutRoutes) {
+            const key = layout.contextKey
+            const loaderFn = loaderCache.get(key)
+            if (loaderFn) {
+              const result = layoutResults.find((r) => r.routeId === key)
+              if (result) {
+                setSSRLoaderData(loaderFn, result.loaderData)
+              }
+            }
+          }
+          const pageLoaderFn = loaderCache.get(route.file)
+          if (pageLoaderFn) {
+            setSSRLoaderData(pageLoaderFn, pageResult.loaderData)
+          }
+
           const headers = new Headers()
           headers.set('content-type', 'text/html')
 
-          // Reset router state for each SSR request to ensure correct routing
-          // TODO: Consider using AsyncLocalStorage to isolate router state per request
-          // instead of using global reset, for better concurrency handling
+          // prepare router for this SSR render (lightweight version bump)
           globalThis['__vxrnresetState']?.()
 
-          const rendered = await (
-            await getRender()
-          )({
+          const renderProps = {
             mode: route.type,
             loaderData,
             loaderProps,
             path: loaderProps?.path || '/',
-            // Use separated preloads for optimal loading
             preloads: buildInfo.criticalPreloads || buildInfo.preloads,
             deferredPreloads: buildInfo.deferredPreloads,
             css: buildInfo.css,
             cssContents: buildInfo.cssContents,
             matches,
-          })
+          }
+
+          // streaming SSR by default, fall back to buffered with ONE_BUFFERED_SSR=1
+          const _rl = ensureRenderLoaded()
+          if (_rl) await _rl
+
+          const streamFn = !process.env.ONE_BUFFERED_SSR ? renderStream : null
+          if (streamFn) {
+            const stream = await streamFn(renderProps)
+            return new Response(stream, {
+              headers,
+              status: route.isNotFound ? 404 : 200,
+            })
+          }
+
+          // render is guaranteed loaded after ensureRenderLoaded above
+          const rendered = await render!(renderProps)
 
           return new Response(rendered, {
             headers,
@@ -417,9 +550,9 @@ url: ${url}`)
 
             globalThis['__vxrnresetState']?.()
 
-            const rendered = await (
-              await getRender()
-            )({
+            const _rl3 = ensureRenderLoaded()
+            if (_rl3) await _rl3
+            const rendered = await render!({
               mode: 'spa-shell',
               // don't pass loaderData for spa-shell - the page loader runs on client
               // passing {} here would make useLoaderState think data is preloaded
@@ -467,7 +600,7 @@ url: ${url}`)
             : routeMap[url.pathname] || routeMap[buildInfo?.cleanPath]
 
         if (htmlPath) {
-          const html = await readStaticHtml(htmlPath)
+          const html = await readStaticHtml(htmlPath, outDir)
 
           if (html) {
             const headers = new Headers()
@@ -486,7 +619,7 @@ url: ${url}`)
           const notFoundHtmlPath = routeMap[notFoundRoute]
 
           if (notFoundHtmlPath) {
-            const notFoundHtml = await readStaticHtml(notFoundHtmlPath)
+            const notFoundHtml = await readStaticHtml(notFoundHtmlPath, outDir)
 
             if (notFoundHtml) {
               // inject 404 marker so client knows this is a 404 response
@@ -571,6 +704,8 @@ url: ${url}`)
             }
 
             const finalUrl = new URL(originalUrl, url.origin)
+            // preserve query params (platform=ios, etc.) for native CJS conversion
+            finalUrl.search = url.search
             const cleanedRequest = new Request(finalUrl, request)
             return resolveLoaderRoute(requestHandlers, cleanedRequest, finalUrl, route)
           }
@@ -742,6 +877,8 @@ url: ${url}`)
         }
 
         const finalUrl = new URL(originalUrl, url.origin)
+        // preserve query params (platform=ios, etc.) for native CJS conversion
+        finalUrl.search = url.search
         const cleanedRequest = new Request(finalUrl, request)
 
         try {

package/src/server/ssrLoaderData.ts

@@ -0,0 +1,8 @@
+// shared weakmap for SSR loader data
+// kept in a separate server-safe module to avoid pulling in client-side
+// dependencies (like @react-navigation/native) into the serve runtime
+export const ssrLoaderData = new WeakMap<Function, any>()
+
+export function setSSRLoaderData(loaderFn: Function, data: any) {
+  ssrLoaderData.set(loaderFn, data)
+}

package/src/server-render.tsx

@@ -4,50 +4,47 @@ export type RenderToStringOptions = {
   /**
    * Critical scripts that need to execute immediately (will use async).
    * These are added to bootstrapModules and generate both modulepreload links and async script tags.
-   * Keep this list minimal (typically: setupClient, one-entry, page entry).
    */
   preloads?: string[]
-
-  /**
-   * Non-critical scripts that can wait (will only be modulepreload hints).
-   * These only generate <link rel="modulepreload"> tags and are loaded when imported.
-   * Use this for component libraries, utilities, and other non-essential modules.
-   */
-  deferredPreloads?: string[]
 }
 
+/**
+ * Buffered SSR - renders to full HTML string.
+ * Deferred preloads and server data are rendered in the React tree
+ * (React 19 hoists <link> to <head>).
+ */
 export const renderToString = async (
   app: React.ReactElement,
   options: RenderToStringOptions
 ) => {
   const readableStream = await ReactDOMServer.renderToReadableStream(app, {
-    // Only pass critical scripts to bootstrapModules
-    // These generate both modulepreload links AND async script tags
     bootstrapModules: options.preloads,
   })
   await readableStream.allReady
-  let out = await streamToString(readableStream)
 
-  // Add non-critical modulepreload links to head (just hints, no script execution)
-  if (options.deferredPreloads?.length) {
-    const modulepreloadLinks = options.deferredPreloads
-      .map((src) => `<link rel="modulepreload" fetchPriority="low" href="${src}"/>`)
-      .join('')
-    out = out.replace('</head>', `${modulepreloadLinks}</head>`)
+  const reader = readableStream.getReader()
+  const decoder = new TextDecoder('utf-8')
+  let out = ''
+
+  while (true) {
+    const { done, value } = await reader.read()
+    if (done) break
+    out += decoder.decode(value, { stream: true })
   }
+  out += decoder.decode()
 
   return out
 }
 
-async function streamToString(stream: ReadableStream<Uint8Array>): Promise<string> {
-  const decoder = new TextDecoder('utf-8', { fatal: true })
-  let result = ''
-
-  // @ts-expect-error TS is wrong, see https://nodejs.org/api/webstreams.html#async-iteration
-  for await (const chunk of stream) {
-    result += decoder.decode(chunk, { stream: true })
-  }
-
-  result += decoder.decode()
-  return result
+/**
+ * Streaming SSR - returns ReadableStream directly.
+ * Skips allReady wait for faster TTFB.
+ */
+export const renderToStream = async (
+  app: React.ReactElement,
+  options: RenderToStringOptions
+): Promise<ReadableStream> => {
+  return ReactDOMServer.renderToReadableStream(app, {
+    bootstrapModules: options.preloads,
+  })
 }

package/src/ui/Slot.tsx

@@ -23,6 +23,13 @@ import { StyleSheet, type ViewProps } from 'react-native'
  */
 function ShimSlotForReactNative(Component: typeof RUISlot): typeof RUISlot {
   return forwardRef(function RNSlotHOC({ style, ...props }, ref) {
+    if (process.env.NODE_ENV !== 'production') {
+      if (Array.isArray(style)) {
+        throw new Error(
+          'Slot does not support array styles. Use StyleSheet.flatten() or an object style instead.'
+        )
+      }
+    }
     style = useMemo(() => StyleSheet.flatten(style), [style])
     return <Component ref={ref} {...props} style={style} />
   })

package/src/ui/TabRouter.tsx

@@ -37,6 +37,24 @@ export function ExpoTabRouter(options: ExpoTabRouterOptions) {
   > = {
     ...rnTabRouter,
     getStateForAction(state, action, options) {
+      // convert REPLACE to JUMP_TO so tab navigators handle it as a tab switch
+      if ((action as any).type === 'REPLACE') {
+        const payload = (action as any).payload
+        return router.getStateForAction(
+          state,
+          {
+            type: 'JUMP_TO' as const,
+            source: (action as any).source,
+            target: (action as any).target,
+            payload: {
+              name: payload?.name ?? '',
+              params: payload?.params,
+            },
+          },
+          options
+        )
+      }
+
       if (action.type !== 'JUMP_TO') {
         return rnTabRouter.getStateForAction(state, action, options)
       }

package/src/ui/TabTrigger.tsx

@@ -251,6 +251,9 @@ export function useTabTrigger(options: TabTriggerProps): UseTabTriggerResult {
 
       if (!shouldHandleMouseEvent(event)) return
 
+      // skip dispatch if this trigger's tab is already focused
+      if (trigger.isFocused) return
+
       switchTab(name, { resetOnFocus })
     },
     [onPress, name, resetOnFocus, trigger, navigation, switchTab]

package/src/useLoader.ts

@@ -2,14 +2,18 @@ import { useCallback, useSyncExternalStore } from 'react'
 import { registerDevtoolsFunction } from './devtools/registry'
 import { useParams, usePathname } from './hooks'
 import { findNearestNotFoundRoute, setNotFoundState } from './notFoundState'
+import { useContextKey } from './router/Route'
+import { getContextKey } from './router/matchers'
 import { router } from './router/imperative-api'
 import { preloadedLoaderData, preloadingLoader, routeNode } from './router/router'
+import { ssrLoaderData } from './server/ssrLoaderData'
 import {
   subscribeToClientMatches,
   getClientMatchesSnapshot,
   updateMatchLoaderData,
 } from './useMatches'
 import { getLoaderPath } from './utils/cleanUrl'
+import { LOADER_JS_POSTFIX_UNCACHED } from './constants'
 import { dynamicImport } from './utils/dynamicImport'
 import { weakKey } from './utils/weakKey'
 import { useServerContext } from './vite/one-server-only'
@@ -311,16 +315,46 @@ export function useLoaderState<
   // (the pathname is already resolved like /docs/getting-started, not /docs/[slug])
   const currentPath = pathname.replace(/\/index$/, '').replace(/\/$/, '') || '/'
 
-  // server-side only - typeof window check ensures this never runs on client
-  if (typeof window === 'undefined' && loader) {
-    const serverData = useAsyncFn(
-      loader,
-      loaderPropsFromServerContext || {
-        path: pathname,
-        params,
+  // server-side only — use pre-resolved loader data so dev and prod behave identically
+  // (no re-running loaders during render, data comes from the same source the client gets)
+  if (typeof window === 'undefined') {
+    if (loader) {
+      // 1) prod: WeakMap keyed by loader function (set by oneServe)
+      if (ssrLoaderData.has(loader)) {
+        return {
+          data: ssrLoaderData.get(loader),
+          refetch: async () => {},
+          state: 'idle',
+        } as any
+      }
+      // 2) dev/fallback: look up this route's data from the matches array in server context
+      //    matches are built with per-route loaderData by both dev and prod handlers
+      //    this avoids re-running loaders during render and keeps dev/prod identical
+      const serverContext = useServerContext()
+      if (serverContext?.matches) {
+        const contextKey = useContextKey()
+        const match = serverContext.matches.find(
+          (m: any) => getContextKey(m.routeId) === contextKey
+        )
+        if (match && match.loaderData !== undefined) {
+          return { data: match.loaderData, refetch: async () => {}, state: 'idle' } as any
+        }
       }
-    )
-    return { data: serverData, refetch: async () => {}, state: 'idle' } as any
+      // 3) last resort fallback: run the loader
+      const serverData = useAsyncFn(
+        loader,
+        loaderPropsFromServerContext || { path: pathname, params }
+      )
+      return { data: serverData, refetch: async () => {}, state: 'idle' } as any
+    }
+    // no loader function (useLoaderState without loader arg) — use page-level data
+    if (loaderDataFromServerContext !== undefined) {
+      return {
+        data: loaderDataFromServerContext,
+        refetch: async () => {},
+        state: 'idle',
+      } as any
+    }
   }
 
   // detect if the loader stub returns a routeId string (set by clientTreeShakePlugin)
@@ -446,8 +480,22 @@ export function useLoaderState<
 
         try {
           if (process.env.TAMAGUI_TARGET === 'native') {
-            const loaderJSUrl = getLoaderPath(currentPath, true)
-            const nativeLoaderJSUrl = `${loaderJSUrl}?platform=ios`
+            let nativeLoaderJSUrl: string
+            if (process.env.NODE_ENV === 'development') {
+              // dev: ?platform=native tells vite plugin to return CJS
+              nativeLoaderJSUrl = `${getLoaderPath(currentPath, true)}?platform=native`
+            } else {
+              // prod: request the .native.js static file directly
+              // use uncached postfix since metro can't inline ONE_CACHE_KEY
+              const { getURL } = require('./getURL')
+              const base = getURL()
+              const cleanedPath = currentPath
+                .slice(1)
+                .replace(/\/$/, '')
+                .replaceAll('_', '__')
+                .replaceAll('/', '_')
+              nativeLoaderJSUrl = `${base}/assets/${cleanedPath}${LOADER_JS_POSTFIX_UNCACHED.replace('.js', '.native.js')}`
+            }
 
             try {
               const moduleLoadStart = performance.now()
@@ -526,6 +574,11 @@ export function useLoaderState<
               })
               return
             } catch (e) {
+              console.error(
+                `[one] native loader error for ${currentPath}:`,
+                e instanceof Error ? e.message : e,
+                `url: ${nativeLoaderJSUrl}`
+              )
               const totalTime = performance.now() - startTime
               updateState(currentPath, {
                 data: {},
@@ -691,6 +744,11 @@ export function useLoader<
 const results = new Map()
 const started = new Map()
 
+// maps loader function → its route's loaderData for SSR
+// populated before render in oneServe.ts, cleared after
+// re-export for backwards compat
+export { setSSRLoaderData } from './server/ssrLoaderData'
+
 export function resetLoaderState() {
   results.clear()
   started.clear()

package/src/utils/isRolldown.ts

@@ -1,17 +1,7 @@
-let _isRolldown: boolean | undefined
+import { version } from 'vite'
 
-export async function isRolldown(): Promise<boolean> {
-  if (_isRolldown !== undefined) {
-    return _isRolldown
-  }
+const majorVersion = parseInt(version.split('.')[0], 10)
 
-  try {
-    const vite = await import('vite')
-    // withFilter only exists in rolldown-vite
-    _isRolldown = 'withFilter' in vite
-  } catch {
-    _isRolldown = false
-  }
-
-  return _isRolldown
+export function isRolldown(): boolean {
+  return majorVersion >= 8
 }