one 1.25.12 → 1.25.15

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/headless-server.ts

@@ -20,7 +20,6 @@
  *     oneOptions: { web: { defaultRenderMode: 'spa' } },
  *     routes: {
  *       api: { '/api/hello': () => import('./api/hello') },
- *       pages: { '/index': () => import('./index') },
  *       middlewares: {},
  *       serverEntry: () => import('./entry-server'),
  *     },

package/src/headless.tsx

@@ -4,6 +4,7 @@ import type { OneLinkingConfig } from './link/getLinking'
 import { Root } from './Root'
 import { resolveClientLoader } from './clientLoaderResolver'
 import { render } from './render'
+import { handleSkewError, isChunkLoadError } from './utils/dynamicImport'
 import { findRootLayout } from './utils/findRootLayout'
 import type { One } from './vite/types'
 
@@ -51,5 +52,9 @@ export function createApp(options: CreateHeadlessAppProps) {
     })
     .catch((err) => {
       console.error(`[one/headless] Error during initialization:`, err)
+      if (isChunkLoadError(err)) {
+        handleSkewError()
+      }
     })
 }
+

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/diagnoseRouteLoadFailure.ts

@@ -28,7 +28,9 @@ function collectImports(source: string, base: string): string[] {
       out.push(new URL(spec, base).href)
     } catch {}
   }
-  for (const m of source.matchAll(/(?:^|[\s;}])(?:import|export)[^'"]{0,300}?from\s*["']([^"']+)["']/g))
+  for (const m of source.matchAll(
+    /(?:^|[\s;}])(?:import|export)[^'"]{0,300}?from\s*["']([^"']+)["']/g
+  ))
     add(m[1])
   for (const m of source.matchAll(/\bimport\s*\(\s*["']([^"']+)["']\s*\)/g)) add(m[1])
   for (const m of source.matchAll(/(?:^|[\s;}])import\s*["']([^"']+)["']/g)) add(m[1])

package/src/router/useViteRoutes.tsx

@@ -1,5 +1,6 @@
 import type { GlobbedRouteImports } from '../types'
 import type { One } from '../vite/types'
+import { handleSkewError, isChunkLoadError } from '../utils/dynamicImport'
 import { diagnoseRouteLoadFailure } from './diagnoseRouteLoadFailure'
 import { hmrImport } from './hmrImport'
 
@@ -146,7 +147,11 @@ export async function preloadRouteModules(href: string): Promise<void> {
           .then((mod: any) => {
             preloadedModules[key] = mod
           })
-          .catch(() => {})
+          .catch((err: any) => {
+            if (isChunkLoadError(err)) {
+              handleSkewError()
+            }
+          })
       )
     }
   }
@@ -284,6 +289,9 @@ export function globbedRoutesToRouteContext(
         })
         .catch((err) => {
           console.error(`Error loading route`, id, err, new Error().stack)
+          if (isChunkLoadError(err)) {
+            handleSkewError()
+          }
           // rendering an empty component keeps one bad route from taking down the
           // app, but it also makes the failure invisible: nothing inside the route
           // mounts and the only trace is the line above. in dev, hand it to the

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 {

package/src/server/oneServe.ts

@@ -16,10 +16,12 @@ import {
 } from '../createHandleRequest'
 import type { RenderAppProps } from '../types'
 import { getPathFromLoaderPath } from '../utils/cleanUrl'
+import { getRouterRootFromOneOptions } from '../utils/getRouterRootFromOneOptions'
 import { toAbsoluteUrl } from '../utils/toAbsolute'
 import { toServerOutputPath } from '../utils/toServerOutputPath'
 import type { One } from '../vite/types'
 import type { RouteInfoCompiled } from './createRoutesManifest'
+import { getRouteExportsFromEntry } from './routeExportsFromEntry'
 import { setSSRLoaderData } from './ssrLoaderData'
 import { getFetchStaticHtml } from './staticHtmlFetcher'
 
@@ -74,8 +76,8 @@ async function readStaticHtml(htmlPath: string, outDir = 'dist'): Promise<string
  * Modules are loaded on-demand when a route is matched, not all upfront.
  */
 type LazyRoutes = {
+  pages?: Record<string, () => Promise<any>>
   serverEntry: () => Promise<{ default: { render: (props: any) => any } }>
-  pages: Record<string, () => Promise<any>>
   api: Record<string, () => Promise<any>>
   middlewares: Record<string, () => Promise<any>>
 }
@@ -150,6 +152,7 @@ export async function oneServe(
   }
 
   const apiCJS = oneOptions.build?.api?.outputFormat === 'cjs'
+  const routerRoot = getRouterRootFromOneOptions(oneOptions)
 
   // pre-computed constants to avoid per-request overhead
   const useStreaming = !process.env.ONE_BUFFERED_SSR
@@ -169,6 +172,26 @@ export async function oneServe(
     { promise: Promise<any>; expires: number }
   >()
 
+  // route modules are resolved through the built server entry, see
+  // routeExportsFromEntry
+  async function importRouteModule(
+    lazyKey: string | undefined,
+    serverPath: string | undefined
+  ): Promise<any> {
+    if (lazyKey && options?.lazyRoutes?.pages?.[lazyKey]) {
+      return await options.lazyRoutes.pages[lazyKey]()
+    }
+    if (lazyKey) {
+      const entry = await loadServerEntry()
+      const exported = await getRouteExportsFromEntry(entry, routerRoot, lazyKey)
+      if (exported) return exported
+    }
+    // layouts and middlewares outside the router root still resolve by path
+    return await import(
+      toAbsoluteUrl(toServerOutputPath(serverPath || lazyKey || '', outDir))
+    )
+  }
+
   // resolve a route module's loader - sync on cache hit, async on cold start
   function resolveLoaderSync(
     serverPath: string | undefined,
@@ -180,18 +203,11 @@ export async function oneServe(
 
     // cold path - async import
     return (async () => {
-      const pathToResolve = serverPath || lazyKey || ''
-      const resolvedPath = toServerOutputPath(pathToResolve, outDir)
-
       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(toAbsoluteUrl(resolvedPath))
-          : await import(toAbsoluteUrl(serverPath!))
+        routeExported = await importRouteModule(lazyKey, serverPath)
         setBounded(moduleImportCache, cacheKey, routeExported, MODULE_CACHE_MAX)
       }
 
@@ -286,18 +302,26 @@ export async function oneServe(
   let render: ((props: RenderAppProps) => any) | null = null
   let renderStream: ((props: RenderAppProps) => Promise<ReadableStream>) | null = null
   let renderLoading: Promise<void> | null = null
+  let entryLoading: Promise<any> | 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(
+  function loadServerEntry(): Promise<any> {
+    if (!entryLoading) {
+      entryLoading = options?.lazyRoutes?.serverEntry
+        ? options.lazyRoutes.serverEntry()
+        : import(
             toAbsoluteUrl(
               `${serverOptions.root}/${outDir}/server/_virtual_one-entry.${typeof oneOptions.build?.server === 'object' && oneOptions.build.server.outputFormat === 'cjs' ? 'c' : ''}js`
             )
           )
+    }
+    return entryLoading
+  }
+
+  function ensureRenderLoaded(): void | Promise<void> {
+    if (render) return // sync!
+    if (renderLoading) return renderLoading
+    renderLoading = (async () => {
+      const entry = await loadServerEntry()
       render = entry.default.render as (props: RenderAppProps) => any
       renderStream = entry.default.renderStream as
         | ((props: RenderAppProps) => Promise<ReadableStream>)

package/src/server/routeExportsFromEntry.ts

@@ -0,0 +1,59 @@
+/**
+ * route modules have to be read through the built server entry's own route map,
+ * never by importing whichever output chunk happens to contain them.
+ *
+ * a bundler makes no promise that a chunk re-exports a module's bindings under
+ * their source names. when a route is both dynamically imported by the entry and
+ * statically imported by another route (docs pages mirrored under a second url,
+ * say), or when the app sets `output.strictExecutionOrder`, rolldown emits the
+ * chunk as
+ *
+ *   export { loader as a, init__slug_ as i, _slug__exports as n, generateStaticParams as r }
+ *
+ * so every read by source name comes back undefined: the build then reports a
+ * route that exports generateStaticParams as missing it, and any loader on that
+ * route silently stops running.
+ *
+ * the entry's `import.meta.glob` map is written by the bundler itself, which
+ * rewrites each entry to whatever preserves the real namespace
+ * (`import(chunk).then((n) => (n.i(), n.n))` for the wrapped case above). so it
+ * resolves correctly no matter how the chunking lands.
+ */
+
+/** the key the entry's globs use: `./posts/[slug]+ssg.tsx` -> `/app/posts/[slug]+ssg.tsx` */
+export function routeEntryKey(routerRoot: string, routeFile: string) {
+  return `/${routerRoot}/${routeFile.replace(/^\.?\//, '')}`
+}
+
+/**
+ * resolve one route's exports out of an already-loaded server entry namespace.
+ * returns null when the entry has no such route.
+ */
+export async function getRouteExportsFromEntry(
+  entry: any,
+  routerRoot: string,
+  routeFile: string
+): Promise<Record<string, any> | null> {
+  const key = routeEntryKey(routerRoot, routeFile)
+
+  // a route that declares spa by filename or parent directory is stubbed out of
+  // the route map, so the server never holds its page component. every stubbed
+  // route has an entry in this parallel per-export map whether or not it
+  // actually exports a loader, which is what tells a stub from a real route. a
+  // route that is spa only because of `web.defaultRenderMode` is never stubbed.
+  const spaExports = entry?.oneServerSpaRouteExports
+  if (spaExports?.loader && key in spaExports.loader) {
+    const [loader, loaderCache, generateStaticParams, sitemap] = await Promise.all([
+      spaExports.loader[key](),
+      spaExports.loaderCache?.[key]?.(),
+      spaExports.generateStaticParams?.[key]?.(),
+      spaExports.sitemap?.[key]?.(),
+    ])
+    return { loader, loaderCache, generateStaticParams, sitemap }
+  }
+
+  // some output formats nest the entry default one level deeper
+  const app = entry?.default?.options ? entry.default : entry?.default?.default
+  const importRoute = app?.options?.routes?.[key]
+  return importRoute ? await importRoute() : null
+}

package/src/server/workerHandler.test.ts

@@ -2,8 +2,9 @@ import { afterEach, describe, expect, it, vi } from 'vitest'
 import type { One } from '../vite/types'
 import { createWorkerHandler, type LazyRoutes } from './workerHandler'
 
+// route files are router-root relative, the way createRoutesManifest emits them
 const pageRoute = {
-  file: 'app/some-page.tsx',
+  file: './some-page.tsx',
   page: '/some-page',
   namedRegex: '^/some-page(?:/)?$',
   urlPath: '/some-page',
@@ -14,7 +15,7 @@ const pageRoute = {
 } satisfies One.BuildInfo['manifest']['pageRoutes'][number]
 
 const apiRoute = {
-  file: 'app/api/status+api.ts',
+  file: './api/status+api.ts',
   page: '/api/status',
   namedRegex: '^/api/status(?:/)?$',
   urlPath: '/api/status',
@@ -57,15 +58,21 @@ const buildInfo = {
   loaders: {},
 } satisfies One.BuildInfo
 
-const lazyRoutes = {
-  serverEntry: async () => ({
+// route modules are reached through the server entry's own route map, keyed by
+// the router-root prefixed path its `import.meta.glob` produces
+const routeKey = `/app/${pageRoute.file.slice(2)}`
+
+const makeServerEntry =
+  (importPage: () => Promise<any> = async () => ({})) =>
+  async () => ({
     default: {
       render: () => '<html></html>',
+      options: { routes: { [routeKey]: importPage } },
     },
-  }),
-  pages: {
-    [pageRoute.file]: async () => ({}),
-  },
+  })
+
+const lazyRoutes = {
+  serverEntry: makeServerEntry(),
   api: {
     [apiRoute.page]: async () => ({
       HEAD: () => new Response(null, { status: 204 }),
@@ -77,7 +84,7 @@ const lazyRoutes = {
 function createHandler() {
   vi.stubEnv('ONE_BUFFERED_SSR', '1')
   return createWorkerHandler({
-    oneOptions: { web: { defaultRenderMode: 'ssr' } },
+    oneOptions: { router: { root: 'app' }, web: { defaultRenderMode: 'ssr' } },
     buildInfo,
     lazyRoutes,
   }).handleRequest
@@ -122,4 +129,25 @@ describe('createWorkerHandler', () => {
     expect(response).toBeInstanceOf(Response)
     expect(response?.status).toBe(204)
   })
+
+  it('disableModuleCache re-imports the page module on each request', async () => {
+    vi.stubEnv('ONE_BUFFERED_SSR', '1')
+    let imports = 0
+    const handleRequest = createWorkerHandler({
+      oneOptions: { router: { root: 'app' }, web: { defaultRenderMode: 'ssr' } },
+      buildInfo,
+      disableModuleCache: true,
+      lazyRoutes: {
+        ...lazyRoutes,
+        serverEntry: makeServerEntry(async () => {
+          imports += 1
+          return {}
+        }),
+      },
+    }).handleRequest
+
+    await handleRequest(new Request('https://example.com/some-page'))
+    await handleRequest(new Request('https://example.com/some-page'))
+    expect(imports).toBeGreaterThan(1)
+  })
 })