one 1.25.12 → 1.25.13

package/src/cli/build.ts

@@ -29,6 +29,13 @@ import { getRouterRootFromOneOptions } from '../utils/getRouterRootFromOneOption
 import { isRolldown } from '../utils/isRolldown'
 import { toAbsolute, toAbsoluteUrl } from '../utils/toAbsolute'
 import { buildVercelOutputDirectory } from '../vercel/build/buildVercelOutputDirectory'
+import {
+  createCloudflareWranglerConfig,
+  getCloudflareProjectName,
+  isPlainObject,
+  loadUserWranglerConfig,
+  type JsonValue,
+} from '../vite/cloudflareWranglerConfig'
 import { getManifest } from '../vite/getManifest'
 import { loadUserOneOptions } from '../vite/loadConfig'
 import { runWithAsyncLocalContext } from '../vite/one-server-only'
@@ -51,191 +58,10 @@ function normalizeDeploy(
   return deploy
 }
 
-type JsonPrimitive = string | number | boolean | null
-type JsonValue = JsonPrimitive | JsonValue[] | { [key: string]: JsonValue }
-
-const GENERATED_CLOUDFLARE_WRANGLER_RULES = [
-  { type: 'ESModule', globs: ['./server/**/*.js'], fallthrough: true },
-  { type: 'ESModule', globs: ['./api/**/*.js'], fallthrough: true },
-  { type: 'ESModule', globs: ['./middlewares/**/*.js'], fallthrough: true },
-  { type: 'ESModule', globs: ['./assets/**/*.js'], fallthrough: true },
-]
-
 const CLOUDFLARE_DEPLOY_WRANGLER_RULES = [
   { type: 'ESModule', globs: ['assets/**/*.js', 'assets/**/*.mjs'] },
 ]
 
-function isPlainObject(value: unknown): value is Record<string, JsonValue> {
-  return !!value && typeof value === 'object' && !Array.isArray(value)
-}
-
-function mergeJsonObjects(
-  base: Record<string, JsonValue>,
-  overrides: Record<string, JsonValue>
-): Record<string, JsonValue> {
-  const merged: Record<string, JsonValue> = { ...base }
-
-  for (const [key, value] of Object.entries(overrides)) {
-    const baseValue = merged[key]
-    if (isPlainObject(baseValue) && isPlainObject(value)) {
-      merged[key] = mergeJsonObjects(baseValue, value)
-    } else {
-      merged[key] = value
-    }
-  }
-
-  return merged
-}
-
-function dedupeJsonValues<T extends JsonValue>(values: T[]): T[] {
-  const seen = new Set<string>()
-  return values.filter((value) => {
-    const key = JSON.stringify(value)
-    if (seen.has(key)) return false
-    seen.add(key)
-    return true
-  })
-}
-
-function mergeCloudflareCompatibilityFlags(flags: unknown): string[] {
-  const userFlags = Array.isArray(flags)
-    ? flags.filter((flag): flag is string => typeof flag === 'string')
-    : []
-
-  return dedupeJsonValues<string>(['nodejs_compat', ...userFlags])
-}
-
-function mergeCloudflareRules(rules: unknown): JsonValue[] {
-  const userRules = Array.isArray(rules)
-    ? rules.filter((rule): rule is JsonValue => isPlainObject(rule))
-    : []
-
-  return dedupeJsonValues<JsonValue>([
-    ...GENERATED_CLOUDFLARE_WRANGLER_RULES,
-    ...userRules,
-  ])
-}
-
-// minimal JSONC parser: strips line/block comments (string-aware) and trailing
-// commas, then runs JSON.parse. sufficient for small hand-written config files.
-function parseJsonc(text: string): unknown {
-  let out = ''
-  let i = 0
-  let inString = false
-  let quote = ''
-  while (i < text.length) {
-    const ch = text[i]
-    const next = text[i + 1]
-    if (inString) {
-      if (ch === '\\') {
-        out += ch + (next ?? '')
-        i += 2
-        continue
-      }
-      if (ch === quote) inString = false
-      out += ch
-      i++
-      continue
-    }
-    if (ch === '"' || ch === "'") {
-      inString = true
-      quote = ch
-      out += ch
-      i++
-      continue
-    }
-    if (ch === '/' && next === '/') {
-      while (i < text.length && text[i] !== '\n') i++
-      continue
-    }
-    if (ch === '/' && next === '*') {
-      i += 2
-      while (i < text.length - 1 && !(text[i] === '*' && text[i + 1] === '/')) i++
-      i += 2
-      continue
-    }
-    out += ch
-    i++
-  }
-  return JSON.parse(out.replace(/,(\s*[}\]])/g, '$1'))
-}
-
-async function loadUserWranglerConfig(
-  root: string
-): Promise<{ path: string; config: Record<string, JsonValue> } | null> {
-  const candidateRoots = [...new Set([root, process.cwd()])]
-
-  for (const candidateRoot of candidateRoots) {
-    for (const fileName of ['wrangler.jsonc', 'wrangler.json']) {
-      const configPath = join(candidateRoot, fileName)
-      if (!(await FSExtra.pathExists(configPath))) {
-        continue
-      }
-
-      const contents = await FSExtra.readFile(configPath, 'utf-8')
-      let parsed: unknown
-      try {
-        parsed = parseJsonc(contents)
-      } catch (err) {
-        throw new Error(
-          `Failed to parse ${relative(process.cwd(), configPath)}: ${(err as Error).message}`
-        )
-      }
-
-      if (!isPlainObject(parsed)) {
-        throw new Error(
-          `Expected ${relative(process.cwd(), configPath)} to contain a top-level JSON object`
-        )
-      }
-
-      return {
-        path: configPath,
-        config: parsed,
-      }
-    }
-  }
-
-  return null
-}
-
-function createCloudflareWranglerConfig(
-  projectName: string,
-  userConfig?: Record<string, JsonValue>
-): Record<string, JsonValue> {
-  const generatedConfig: Record<string, JsonValue> = {
-    name: projectName,
-    main: 'worker.js',
-    compatibility_date: '2024-12-05',
-    compatibility_flags: ['nodejs_compat'],
-    find_additional_modules: true,
-    rules: GENERATED_CLOUDFLARE_WRANGLER_RULES,
-    assets: {
-      directory: 'client',
-      binding: 'ASSETS',
-      run_worker_first: true,
-    },
-  }
-
-  const mergedConfig = userConfig
-    ? mergeJsonObjects(generatedConfig, userConfig)
-    : generatedConfig
-
-  mergedConfig.main = 'worker.js'
-  mergedConfig.find_additional_modules = true
-  mergedConfig.compatibility_flags = mergeCloudflareCompatibilityFlags(
-    mergedConfig.compatibility_flags
-  )
-  mergedConfig.rules = mergeCloudflareRules(mergedConfig.rules)
-  mergedConfig.assets = {
-    ...(isPlainObject(mergedConfig.assets) ? mergedConfig.assets : {}),
-    directory: 'client',
-    binding: 'ASSETS',
-    run_worker_first: true,
-  }
-
-  return mergedConfig
-}
-
 function omitEmptyJsonValues(value: JsonValue): JsonValue | undefined {
   if (Array.isArray(value)) {
     const items = value
@@ -276,17 +102,6 @@ async function finalizeCloudflareWranglerDeployConfig(configPath: string) {
   await FSExtra.writeFile(configPath, `${JSON.stringify(config, null, 2)}\n`)
 }
 
-// reads package.json name, strips npm scope prefix for use as cloudflare worker name
-async function getCloudflareProjectName(root: string): Promise<string> {
-  try {
-    const pkg = JSON.parse(await FSExtra.readFile(join(root, 'package.json'), 'utf-8'))
-    if (pkg.name) {
-      return pkg.name.replace(/^@[^/]+\//, '')
-    }
-  } catch {}
-  return 'one-app'
-}
-
 // ensure worker threads inherit the same CACHE_KEY as the main process
 process.env.ONE_CACHE_KEY = constants.CACHE_KEY
 

package/src/createDevHandleRequest.ts

@@ -0,0 +1,186 @@
+import { LOADER_JS_POSTFIX_UNCACHED } from './constants'
+import {
+  compileManifest,
+  getURLfromRequestURL,
+  isPageRequestMethod,
+  isStaticAssetRequestPath,
+  resolveAPIRoute,
+  resolveLoaderRoute,
+  resolvePageRoute,
+  runMiddlewares,
+  type RequestHandlerResponse,
+  type RequestHandlers,
+} from './createHandleRequest'
+import { getPathFromLoaderPath } from './utils/cleanUrl'
+import { getManifest } from './vite/getManifest'
+
+const debugRouter = process.env.ONE_DEBUG_ROUTER
+
+// node-dev request handler. kept out of createHandleRequest.ts so the worker
+// graph (one/serve-worker) does not pull getManifest -> micromatch/fast-glob.
+export function createHandleRequest(
+  handlers: RequestHandlers,
+  {
+    routerRoot,
+    ignoredRouteFiles,
+    routePaths,
+  }: { routerRoot: string; ignoredRouteFiles?: string[]; routePaths?: string[] }
+) {
+  const manifest = getManifest({ routerRoot, ignoredRouteFiles, routePaths })
+  if (!manifest) {
+    throw new Error(`No routes manifest`)
+  }
+  const compiledManifest = compileManifest(manifest)
+
+  return {
+    manifest,
+    handler: async function handleRequest(
+      request: Request
+    ): Promise<RequestHandlerResponse> {
+      const url = getURLfromRequestURL(request)
+      const { pathname } = url
+
+      // skip paths handled by vite internals or react native dev middleware
+      if (
+        pathname === '/__vxrnhmr' ||
+        pathname.startsWith('/@vite/') ||
+        pathname.startsWith('/@fs/') ||
+        pathname.startsWith('/@id/') ||
+        pathname.startsWith('/node_modules/') ||
+        pathname.startsWith('/debugger-frontend') ||
+        pathname.startsWith('/inspector')
+      ) {
+        return null
+      }
+
+      const looksLikeStaticFile = isStaticAssetRequestPath(pathname)
+
+      if (handlers.handleAPI) {
+        const apiRoute = compiledManifest.apiRoutes.find((route) => {
+          return route.compiledRegex.test(pathname)
+        })
+        if (apiRoute) {
+          if (debugRouter) {
+            console.info(`[one] ⚡ ${pathname} → matched API route: ${apiRoute.page}`)
+          }
+          return await resolveAPIRoute(handlers, request, url, apiRoute)
+        }
+      }
+
+      if (!isPageRequestMethod(request.method)) {
+        return null
+      }
+
+      if (handlers.handleLoader) {
+        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) {
+            if (route.file === '') {
+              // ignore not found route
+              continue
+            }
+
+            const finalUrl = new URL(originalUrl, url.origin)
+            finalUrl.search = url.search
+
+            if (!route.compiledRegex.test(finalUrl.pathname)) {
+              continue
+            }
+
+            // route is known to export no loader → return empty module without
+            // importing the page bundle. on workerd/cloudflare, evaluating a
+            // no-loader SSG page's server bundle can crash when it pulls in
+            // RN/Tamagui modules that aren't compatible with the workers runtime.
+            if (route.hasLoader === false) {
+              const emptyBody = isNativePlatform
+                ? 'exports.loader=function(){return undefined}'
+                : 'export function loader() { return undefined }'
+              return new Response(emptyBody, {
+                headers: { 'Content-Type': 'text/javascript' },
+              })
+            }
+
+            const cleanedRequest = new Request(finalUrl, request)
+            return resolveLoaderRoute(handlers, cleanedRequest, finalUrl, route)
+          }
+
+          // no matching route - return empty module so client handles gracefully
+          const emptyBody = isNativePlatform
+            ? 'exports.loader=function(){return{}}'
+            : 'export {}'
+          return new Response(emptyBody, {
+            headers: { 'Content-Type': 'text/javascript' },
+          })
+        }
+      }
+
+      if (handlers.handlePage) {
+        for (const route of compiledManifest.pageRoutes) {
+          if (!route.compiledRegex.test(pathname)) {
+            continue
+          }
+
+          // static asset requests (sourcemaps, favicons, fonts, …) should not
+          // SSR the user's +not-found page or hijack a dynamic route. for
+          // +not-found we still run middleware so it can intercept, then
+          // short-circuit to a bare 404 instead of rendering the page tree.
+          const isDynamicRoute = Object.keys(route.routeKeys).length > 0
+          const isNotFoundRoute = route.page.endsWith('/+not-found')
+          if (looksLikeStaticFile && isNotFoundRoute) {
+            if (debugRouter) {
+              console.info(
+                `[one] ⚡ ${pathname} → bare 404 for static probe on ${route.page}`
+              )
+            }
+            if (!route.middlewares?.length) {
+              return null
+            }
+            return await runMiddlewares(handlers, request, route, async () => {
+              return new Response(null, {
+                status: 404,
+                headers: { 'Content-Type': 'text/plain' },
+              })
+            })
+          }
+          if (looksLikeStaticFile && isDynamicRoute) {
+            if (debugRouter) {
+              console.info(
+                `[one] ⚡ ${pathname} → skipping dynamic route ${route.page} for static asset`
+              )
+            }
+            continue
+          }
+
+          if (debugRouter) {
+            console.info(
+              `[one] ⚡ ${pathname} → matched page route: ${route.page} (${route.type})`
+            )
+          }
+
+          return resolvePageRoute(handlers, request, url, route)
+        }
+      }
+
+      return null
+    },
+  }
+}

package/src/createHandleRequest.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it, vi, beforeEach } from 'vitest'
-import { createHandleRequest } from './createHandleRequest'
+import { createHandleRequest } from './createDevHandleRequest'
 
 // Mock the manifest. Specific routes come before dynamic ones, matching how
 // the real manifest is ordered after matchers.sortRoutes().

package/src/createHandleRequest.ts

@@ -3,9 +3,7 @@ import type { Middleware, MiddlewareContext } from './createMiddleware'
 import type { RouteNode } from './router/Route'
 import type { RouteInfoCompiled } from './server/createRoutesManifest'
 import type { LoaderProps } from './types'
-import { getPathFromLoaderPath } from './utils/cleanUrl'
 import { isResponse } from './utils/isResponse'
-import { getManifest } from './vite/getManifest'
 import { resolveAPIEndpoint, resolveResponse } from './vite/resolveResponse'
 import type { RouteInfo } from './vite/types'
 
@@ -24,12 +22,12 @@ type RequestHandlerProps<RouteExtraProps extends object = {}> = {
   loaderProps?: LoaderProps
 }
 
-type RequestHandlerResponse = null | string | Response
+export type RequestHandlerResponse = null | string | Response
 
 const debugRouter = process.env.ONE_DEBUG_ROUTER
 const staticAssetPathRe = /\.(?:[a-z0-9]{2,4}|webmanifest|wasm|woff2)$/i
 
-function isStaticAssetRequestPath(pathname: string): boolean {
+export function isStaticAssetRequestPath(pathname: string): boolean {
   return (
     !pathname.endsWith(LOADER_JS_POSTFIX_UNCACHED) && staticAssetPathRe.test(pathname)
   )
@@ -382,174 +380,6 @@ export function compileManifest(manifest: {
   }
 }
 
-// in dev mode we do it more simply:
-export function createHandleRequest(
-  handlers: RequestHandlers,
-  {
-    routerRoot,
-    ignoredRouteFiles,
-    routePaths,
-  }: { routerRoot: string; ignoredRouteFiles?: string[]; routePaths?: string[] }
-) {
-  const manifest = getManifest({ routerRoot, ignoredRouteFiles, routePaths })
-  if (!manifest) {
-    throw new Error(`No routes manifest`)
-  }
-  const compiledManifest = compileManifest(manifest)
-
-  return {
-    manifest,
-    handler: async function handleRequest(
-      request: Request
-    ): Promise<RequestHandlerResponse> {
-      const url = getURLfromRequestURL(request)
-      const { pathname, search } = url
-
-      // skip paths handled by vite internals or react native dev middleware
-      if (
-        pathname === '/__vxrnhmr' ||
-        pathname.startsWith('/@vite/') ||
-        pathname.startsWith('/@fs/') ||
-        pathname.startsWith('/@id/') ||
-        pathname.startsWith('/node_modules/') ||
-        pathname.startsWith('/debugger-frontend') ||
-        pathname.startsWith('/inspector')
-      ) {
-        return null
-      }
-
-      const looksLikeStaticFile = isStaticAssetRequestPath(pathname)
-
-      if (handlers.handleAPI) {
-        const apiRoute = compiledManifest.apiRoutes.find((route) => {
-          return route.compiledRegex.test(pathname)
-        })
-        if (apiRoute) {
-          if (debugRouter) {
-            console.info(`[one] ⚡ ${pathname} → matched API route: ${apiRoute.page}`)
-          }
-          return await resolveAPIRoute(handlers, request, url, apiRoute)
-        }
-      }
-
-      if (!isPageRequestMethod(request.method)) {
-        return null
-      }
-
-      if (handlers.handleLoader) {
-        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) {
-            if (route.file === '') {
-              // ignore not found route
-              continue
-            }
-
-            const finalUrl = new URL(originalUrl, url.origin)
-            finalUrl.search = url.search
-
-            if (!route.compiledRegex.test(finalUrl.pathname)) {
-              continue
-            }
-
-            // route is known to export no loader → return empty module without
-            // importing the page bundle. on workerd/cloudflare, evaluating a
-            // no-loader SSG page's server bundle can crash when it pulls in
-            // RN/Tamagui modules that aren't compatible with the workers runtime.
-            if (route.hasLoader === false) {
-              const emptyBody = isNativePlatform
-                ? 'exports.loader=function(){return undefined}'
-                : 'export function loader() { return undefined }'
-              return new Response(emptyBody, {
-                headers: { 'Content-Type': 'text/javascript' },
-              })
-            }
-
-            const cleanedRequest = new Request(finalUrl, request)
-            return resolveLoaderRoute(handlers, cleanedRequest, finalUrl, route)
-          }
-
-          // no matching route - return empty module so client handles gracefully
-          const emptyBody = isNativePlatform
-            ? 'exports.loader=function(){return{}}'
-            : 'export {}'
-          return new Response(emptyBody, {
-            headers: { 'Content-Type': 'text/javascript' },
-          })
-        }
-      }
-
-      if (handlers.handlePage) {
-        for (const route of compiledManifest.pageRoutes) {
-          if (!route.compiledRegex.test(pathname)) {
-            continue
-          }
-
-          // static asset requests (sourcemaps, favicons, fonts, …) should not
-          // SSR the user's +not-found page or hijack a dynamic route. for
-          // +not-found we still run middleware so it can intercept, then
-          // short-circuit to a bare 404 instead of rendering the page tree.
-          const isDynamicRoute = Object.keys(route.routeKeys).length > 0
-          const isNotFoundRoute = route.page.endsWith('/+not-found')
-          if (looksLikeStaticFile && isNotFoundRoute) {
-            if (debugRouter) {
-              console.info(
-                `[one] ⚡ ${pathname} → bare 404 for static probe on ${route.page}`
-              )
-            }
-            if (!route.middlewares?.length) {
-              return null
-            }
-            return await runMiddlewares(handlers, request, route, async () => {
-              return new Response(null, {
-                status: 404,
-                headers: { 'Content-Type': 'text/plain' },
-              })
-            })
-          }
-          if (looksLikeStaticFile && isDynamicRoute) {
-            if (debugRouter) {
-              console.info(
-                `[one] ⚡ ${pathname} → skipping dynamic route ${route.page} for static asset`
-              )
-            }
-            continue
-          }
-
-          if (debugRouter) {
-            console.info(
-              `[one] ⚡ ${pathname} → matched page route: ${route.page} (${route.type})`
-            )
-          }
-
-          return resolvePageRoute(handlers, request, url, route)
-        }
-      }
-
-      return null
-    },
-  }
-}
-
 export function getLoaderParams(
   url: URL,
   config: { compiledRegex: RegExp; routeKeys: Record<string, string> }

package/src/layouts/Drawer.web.tsx

@@ -15,7 +15,6 @@ import {
 import { Children, type ComponentProps, forwardRef, type ReactNode } from 'react'
 
 import { getCustomNavigatorChildren, isNavigatorConfigChild } from '../headless/children'
-import { devHeadlessNote } from '../headless/devHeadlessNote'
 import { renderKeptMountedScreens, useVisitedScreens } from '../headless/keepMounted'
 import {
   DrawerStateProvider,
@@ -75,8 +74,6 @@ function HeadlessDrawerView({ customChildren }: { customChildren?: ReactNode[] }
   const { screens, focused } = useDrawer()
   const visited = useVisitedScreens(focused.key)
 
-  devHeadlessNote('Drawer')
-
   if (customChildren?.length) {
     return <>{customChildren}</>
   }

package/src/layouts/Tabs.web.tsx

@@ -11,7 +11,6 @@ import {
 import { Children, Fragment, forwardRef, type ReactNode, useMemo, useRef } from 'react'
 import { getPathFromState } from '../fork/getPathFromState'
 import { getCustomNavigatorChildren, isNavigatorConfigChild } from '../headless/children'
-import { devHeadlessNote } from '../headless/devHeadlessNote'
 import { renderKeptMountedScreens, useVisitedScreens } from '../headless/keepMounted'
 import { useTabs } from '../headless/useTabs'
 import { getResolvedLinking } from '../router/linkingConfig'
@@ -118,7 +117,6 @@ function WebTabsNavigator({
 function HeadlessTabsView({ customChildren }: { customChildren?: ReactNode[] }) {
   const { screens, focused } = useTabs()
   const visited = useVisitedScreens(focused.key)
-  devHeadlessNote('Tabs')
 
   if (customChildren?.length) {
     return <Fragment>{customChildren}</Fragment>

package/src/router/web/WebStackView.tsx

@@ -21,7 +21,6 @@ import {
 } from 'react'
 import useLatestCallback from 'use-latest-callback'
 
-import { devHeadlessNote } from '../../headless/devHeadlessNote'
 import { useWebPresentations } from '../../headless/Presentations'
 import type {
   ModalPresentationOptions,
@@ -95,8 +94,6 @@ function HeadlessStackView({
     return <Fragment>{customChildren}</Fragment>
   }
 
-  devHeadlessNote('Stack')
-
   const lastBaseIndex = findLastNonOverlayIndex(
     state,
     descriptors,

package/src/serve-worker.ts

@@ -19,7 +19,11 @@ export type { LazyRoutes }
  *          API route handler contexts as `{ env, executionCtx }`).
  *          Call `updateRoutes(newBuildInfo, newLazyRoutes?)` to hot-swap the route table.
  */
-export async function serve(buildInfo: One.BuildInfo, lazyRoutes?: LazyRoutes) {
+export async function serve(
+  buildInfo: One.BuildInfo,
+  lazyRoutes?: LazyRoutes,
+  serveOptions?: { disableModuleCache?: boolean }
+) {
   setupBuildInfo(buildInfo)
   ensureExists(buildInfo.oneOptions)
   setServerGlobals()
@@ -28,6 +32,7 @@ export async function serve(buildInfo: One.BuildInfo, lazyRoutes?: LazyRoutes) {
     oneOptions: buildInfo.oneOptions!,
     buildInfo,
     lazyRoutes: lazyRoutes!,
+    disableModuleCache: serveOptions?.disableModuleCache,
   })
 
   return {