one 1.25.12 → 1.25.15

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'
@@ -38,6 +45,7 @@ import { checkNodeVersion } from './checkNodeVersion'
 import { getWorkerPool, terminateWorkerPool } from './workerPool'
 import { generateSitemap, type RouteSitemapData } from './generateSitemap'
 import { labelProcess } from './label-process'
+import { getRouteExports } from './serverRouteModules'
 import { pLimit } from '../utils/pLimit'
 import { getCriticalCSSOutputPaths } from '../vite/plugins/criticalCSSPlugin'
 
@@ -51,191 +59,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 +103,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
 
@@ -722,17 +538,36 @@ export async function build(args: {
   }
 
   // build a direct mapping from source file path to client chunk info
-  // this is more reliable than manifest.json which can have ambiguous keys
+  // this is more reliable than manifest.json which can have ambiguous keys.
+  // index every module a chunk contains, not just its facade: a route that
+  // another route re-exports from stops being a dynamic entry and lands in a
+  // plain shared chunk, which has no facade and so gets no source-path key in
+  // the manifest either. the facade pass runs second so it wins where both hit.
   const clientChunksBySource = new Map<string, { fileName: string; imports: string[] }>()
   if (vxrnOutput.clientOutput) {
     for (const chunk of vxrnOutput.clientOutput) {
-      if (chunk.type === 'chunk' && chunk.facadeModuleId) {
-        clientChunksBySource.set(chunk.facadeModuleId, {
-          fileName: chunk.fileName,
-          imports: chunk.imports || [],
-        })
+      if (chunk.type !== 'chunk') continue
+      const info = { fileName: chunk.fileName, imports: chunk.imports || [] }
+      for (const moduleId of chunk.moduleIds ?? []) {
+        clientChunksBySource.set(moduleId, info)
       }
     }
+    for (const chunk of vxrnOutput.clientOutput) {
+      if (chunk.type !== 'chunk' || !chunk.facadeModuleId) continue
+      clientChunksBySource.set(chunk.facadeModuleId, {
+        fileName: chunk.fileName,
+        imports: chunk.imports || [],
+      })
+    }
+  }
+
+  // the manifest keys chunks by source path only when they have a facade, so
+  // reach the rest through the chunk file name that clientChunksBySource gives us
+  const clientManifestByFile = new Map<string, ClientManifestEntry>()
+  for (const entry of Object.values(vxrnOutput.clientManifest) as ClientManifestEntry[]) {
+    if (entry.file) {
+      clientManifestByFile.set(entry.file, entry)
+    }
   }
 
   const outputEntries = [...vxrnOutput.serverOutput.entries()]
@@ -828,7 +663,9 @@ export async function build(args: {
 
     // also look up in manifest for additional info (css, nested imports, etc)
     const manifestKey = `${routerRoot}${foundRoute.file.slice(1)}`
-    const clientManifestEntry = vxrnOutput.clientManifest[manifestKey]
+    const clientManifestEntry: ClientManifestEntry | undefined =
+      vxrnOutput.clientManifest[manifestKey] ??
+      (clientChunk ? clientManifestByFile.get(clientChunk.fileName) : undefined)
 
     // SPA and SSG routes may not have client chunks - that's expected
     if (!clientChunk && foundRoute.type !== 'spa' && foundRoute.type !== 'ssg') {
@@ -853,7 +690,7 @@ export async function build(args: {
     }
 
     function collectImports(
-      entry: ClientManifestEntry,
+      entry: Partial<ClientManifestEntry>,
       { type = 'js' }: { type?: 'js' | 'css' } = {}
     ): string[] {
       const { imports = [], css } = entry
@@ -924,13 +761,9 @@ export async function build(args: {
     }
 
     // add the page itself using the direct chunk lookup (more reliable than manifest)
-    if (clientChunk) {
-      const routeKey = `/${routerRoot}${foundRoute.file.slice(1)}`
-      routePreloads[routeKey] = `/${clientChunk.fileName}`
-    } else if (clientManifestEntry) {
-      // fallback to manifest if no chunk (shouldn't happen normally)
-      const routeKey = `/${routerRoot}${foundRoute.file.slice(1)}`
-      routePreloads[routeKey] = `/${clientManifestEntry.file}`
+    const routeChunkFile = clientChunk?.fileName ?? clientManifestEntry?.file
+    if (routeChunkFile) {
+      routePreloads[`/${routerRoot}${foundRoute.file.slice(1)}`] = `/${routeChunkFile}`
     }
 
     const preloadSetupFilePreloads = (() => {
@@ -1106,11 +939,15 @@ export async function build(args: {
 
     let exported
     try {
-      exported = await import(toAbsoluteUrl(serverJsPath))
+      exported = await getRouteExports(
+        vxrnOutput.serverEntry,
+        routerRoot,
+        foundRoute.file
+      )
     } catch (err) {
       console.error(`Error importing page (original error)`, err)
       // err cause not showing in vite or something
-      throw new Error(`Error importing page: ${serverJsPath}`, {
+      throw new Error(`Error importing page: ${foundRoute.file}`, {
         cause: err,
       })
     }
@@ -1180,6 +1017,7 @@ export async function build(args: {
         return workerPool
           .buildPage({
             serverEntry: vxrnOutput.serverEntry,
+            routerRoot,
             path,
             relativeId,
             params,
@@ -1209,6 +1047,7 @@ export async function build(args: {
         const built = await runWithAsyncLocalContext(async () => {
           return await buildPage(
             vxrnOutput.serverEntry,
+            routerRoot,
             path,
             relativeId,
             params,
@@ -1435,21 +1274,9 @@ export async function build(args: {
         )
         return importPath.startsWith('.') ? importPath : `./${importPath}`
       }
-      const pageRouteMap: string[] = []
       const apiRouteMap: string[] = []
       const middlewareRouteMap: string[] = []
 
-      // Generate lazy imports for SSR/SSG page server bundles
-      for (const [routeFile, info] of Object.entries(
-        buildInfoForWriting.routeToBuildInfo
-      )) {
-        if (info.serverJsPath) {
-          const importPath =
-            './' + info.serverJsPath.replace(new RegExp(`^${outDir}/`), '')
-          pageRouteMap.push(`  '${routeFile}': () => import('${importPath}')`)
-        }
-      }
-
       // Generate lazy imports for API routes
       for (const route of buildInfoForWriting.manifest.apiRoutes) {
         if (route.file) {
@@ -1484,9 +1311,6 @@ import { serve, setFetchStaticHtml } from 'one/serve-worker'
 // Lazy import map - modules load on-demand when route is matched
 const lazyRoutes = {
   serverEntry: () => import('./server/_virtual_one-entry.js'),
-  pages: {
-${pageRouteMap.join(',\n')}
-  },
   api: {
 ${apiRouteMap.join(',\n')}
   },

package/src/cli/buildPage.ts

@@ -14,6 +14,7 @@ import { isResponse } from '../utils/isResponse'
 import { toAbsolute, toAbsoluteUrl } from '../utils/toAbsolute'
 import { replaceLoader } from '../vite/replaceLoader'
 import type { One, RouteInfo } from '../vite/types'
+import { getRouteExports } from './serverRouteModules'
 
 const { readFile, outputFile } = FSExtra
 
@@ -45,6 +46,7 @@ export function printBuildTimings() {
 
 export async function buildPage(
   serverEntry: string,
+  routerRoot: string,
   path: string,
   relativeId: string,
   params: any,
@@ -186,7 +188,7 @@ prefetchCSS()
     recordTiming('writeCSSPreload', performance.now() - t0)
 
     t0 = performance.now()
-    const exported = await import(toAbsoluteUrl(serverJsPath))
+    const exported = await getRouteExports(serverEntry, routerRoot, foundRoute.file)
     recordTiming('importServerModule', performance.now() - t0)
 
     const loaderProps: LoaderProps = { path, params }
@@ -200,14 +202,13 @@ prefetchCSS()
       const layoutResults = await Promise.all(
         foundRoute.layouts.map(async (layout) => {
           try {
-            const layoutServerPath = layout.loaderServerPath
-            if (!layoutServerPath) {
+            if (!layout.loaderServerPath) {
               return { contextKey: layout.contextKey, loaderData: undefined }
             }
-            // derive server dir from clientDir (e.g. dist/client -> dist/server)
-            const serverDir = join(clientDir, '..', 'server')
-            const layoutExported = await import(
-              toAbsoluteUrl(join(serverDir, layoutServerPath))
+            const layoutExported = await getRouteExports(
+              serverEntry,
+              routerRoot,
+              layout.contextKey
             )
             const layoutLoaderData = await layoutExported?.loader?.(loaderProps)
             return { contextKey: layout.contextKey, loaderData: layoutLoaderData }
@@ -301,6 +302,7 @@ if (typeof document === 'undefined') globalThis.document = {}
             replaceLoader({
               code,
               loaderData,
+              routeId: foundRoute.file,
             })
           await outputFile(loaderPartialPath, withLoader)
           // native-friendly CJS version with just the data (no ESM imports)

package/src/cli/buildPageWorker.ts

@@ -68,6 +68,7 @@ parentPort.on('message', async (msg: any) => {
       const result = await runWithAsyncLocalContext(async () => {
         return await buildPage(
           msg.args.serverEntry,
+          msg.args.routerRoot,
           msg.args.path,
           msg.args.relativeId,
           msg.args.params,

package/src/cli/serverRouteModules.ts

@@ -0,0 +1,33 @@
+import { getRouteExportsFromEntry } from '../server/routeExportsFromEntry'
+import { toAbsoluteUrl } from '../utils/toAbsolute'
+
+// entry evaluation is expensive and every page in a build shares it
+const serverEntries = new Map<string, Promise<any>>()
+
+function loadServerEntry(serverEntry: string) {
+  let loading = serverEntries.get(serverEntry)
+  if (!loading) {
+    loading = import(toAbsoluteUrl(serverEntry))
+    serverEntries.set(serverEntry, loading)
+  }
+  return loading
+}
+
+export async function getRouteExports(
+  serverEntry: string,
+  routerRoot: string,
+  routeFile: string
+): Promise<Record<string, any>> {
+  const entry = await loadServerEntry(serverEntry)
+  const exported = await getRouteExportsFromEntry(entry, routerRoot, routeFile)
+
+  if (!exported) {
+    const routes =
+      entry?.default?.options?.routes ?? entry?.default?.default?.options?.routes
+    throw new Error(
+      `[one] route ${routeFile} is missing from the built server entry route map (looked in: ${Object.keys(routes ?? {}).join(', ')})`
+    )
+  }
+
+  return exported
+}

package/src/cli/workerPool.ts

@@ -105,6 +105,7 @@ export class BuildWorkerPool {
 
   async buildPage(args: {
     serverEntry: string
+    routerRoot: string
     path: string
     relativeId: string
     params: any

package/src/createApp.tsx

@@ -7,7 +7,7 @@ import { render } from './render'
 import { initClientMatches } from './router/router'
 import { registerPreloadedRoute } from './router/useViteRoutes'
 import { setupSkewProtection } from './skewProtection'
-import { handleSkewError } from './utils/dynamicImport'
+import { handleSkewError, isChunkLoadError } from './utils/dynamicImport'
 import { findRootLayout } from './utils/findRootLayout'
 import type { RenderAppProps } from './types'
 import type { OneLinkingConfig } from './link/getLinking'
@@ -293,5 +293,9 @@ export function createApp(options: CreateAppProps) {
     })
     .catch((err) => {
       console.error(`Error during client initialization:`, err)
+      if (isChunkLoadError(err)) {
+        handleSkewError()
+      }
     })
 }
+

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().