@wular/pnext 0.1.6 → 0.1.8

package/src/compat/lifecycle/testmode.ts

@@ -18,9 +18,8 @@ import { currentRequest, getWorkUnit } from '../../request/context'
 // readonly property." `require()` returns the real, mutable CJS exports
 // object that node/http/https resolve `.get` calls through at runtime, so
 // patch that instead of the namespace binding.
+// Required on install, not at import: loading node:http/https costs every build ~10 ms.
 const requireNode = createRequire(import.meta.url)
-const httpModule = requireNode('node:http') as typeof http
-const httpsModule = requireNode('node:https') as typeof https
 
 interface TestProxyInfo {
   proxyPort: number
@@ -284,6 +283,8 @@ export function installTestProxyFetch(): void {
   ;(testFetch as typeof fetch).preconnect = originalFetch.preconnect?.bind(originalFetch)
   globalThis.fetch = testFetch as typeof fetch
 
+  const httpModule = requireNode('node:http') as typeof http
+  const httpsModule = requireNode('node:https') as typeof https
   const originalHttpGet = httpModule.get
   const originalHttpsGet = httpsModule.get
   httpModule.get = patchableGet(originalHttpGet, originalFetch)

package/src/compat/metadata-artifacts.ts

@@ -329,7 +329,7 @@ async function writeStaticMetadataArtifacts(
   metadata: StaticFileMetadata | undefined,
 ): Promise<void> {
   if (!metadata) return
-  const source = path.join(outPath, 'public', relative)
+  const source = path.join(outPath, 'static', relative)
   const outputBase = path.join(root, 'server', 'app', toPosixPath(relative))
   await mkdir(path.dirname(outputBase), { recursive: true })
   const routeMeta = JSON.stringify(toRouteMeta(metadata))

package/src/compat/next/config-loader.ts

@@ -13,7 +13,15 @@
 // export / top-level await / dynamic import() and CJS+ESM authoring styles.
 // ---------------------------------------------------------------------------
 
-import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from 'node:fs'
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  renameSync,
+  rmSync,
+  writeFileSync,
+} from 'node:fs'
 import { createRequire } from 'node:module'
 import path from 'node:path'
 import { pathToFileURL } from 'node:url'
@@ -43,6 +51,12 @@ const CONFIG_BASENAMES = [
 ]
 
 let store: NextConfigObject = {}
+let storeReleased = false
+
+/** Whether the stored config came from a production release, which no consumer may re-read from source. */
+export function nextConfigReleased(): boolean {
+  return storeReleased
+}
 
 /** The full loaded next.config object; empty until loadNextConfig runs. */
 export function getNextConfig(): NextConfigObject {
@@ -188,19 +202,104 @@ async function importConfigModule(
   return importConfigBundle(outfile, cjs)
 }
 
+/**
+ * Compile the app's next.config into `outDir`, plus the cache handlers it names, so a production server
+ * imports neither from source. Names carry a content hash: a rebuilt release never reuses the previous
+ * generation's module instance. Paths are relative to the bundle, so the release can move.
+ */
+export async function emitNextConfigBundle(root: string, outDir: string) {
+  const configPath = findConfigPath(root)
+  if (!configPath) return undefined
+  const cjs = cjsConfigFormat(configPath, root)
+  const [file, ...handlerFiles] = await Promise.all([
+    hashedOutput(outDir, 'next.config', cjs ? '.cjs' : '.mjs', outfile =>
+      bundleConfig({ configPath, root, outDir, outfile, cjs, relocatable: true }),
+    ),
+    ...cacheHandlerFiles(store).map(([name, source]) =>
+      hashedOutput(outDir, name, '.cjs', outfile =>
+        build({
+          entryPoints: [source],
+          outfile,
+          bundle: true,
+          platform: 'node',
+          format: 'cjs',
+          target: 'esnext',
+          packages: 'external',
+          logLevel: 'silent',
+        }),
+      ).then(output => [name, output] as const),
+    ),
+  ])
+  return { file, handlers: Object.fromEntries(handlerFiles as [string, string][]) }
+}
+
+/** Write through `emit` to a temporary name, then publish as `<name>.<content hash><ext>`. */
+async function hashedOutput(
+  outDir: string,
+  name: string,
+  ext: string,
+  emit: (outfile: string) => Promise<unknown>,
+) {
+  const temporary = path.join(outDir, `${name}.${process.pid}.tmp${ext}`)
+  await emit(temporary)
+  const hash = bun.hash(readFileSync(temporary)).toString(36)
+  const outfile = path.join(outDir, `${name}.${hash}${ext}`)
+  renameSync(temporary, outfile)
+  return outfile
+}
+
+/** The configured cache handler sources, by the name their release bundle takes. */
+function cacheHandlerFiles(config: NextConfigObject): [string, string][] {
+  const handlers = config.cacheHandlers as Record<string, unknown> | undefined
+  return [
+    ['cache-handler', config.cacheHandler],
+    [
+      'cache-handler-default',
+      handlers && typeof handlers === 'object' ? handlers.default : undefined,
+    ],
+  ].filter(
+    (entry): entry is [string, string] =>
+      typeof entry[1] === 'string' && path.isAbsolute(entry[1]) && existsSync(entry[1]),
+  )
+}
+
+/** Point a released config's cache handlers at the bundles its build emitted. */
+function releasedCacheHandlers(
+  config: NextConfigObject,
+  handlers: Record<string, string>,
+): NextConfigObject {
+  const handler = handlers['cache-handler']
+  const fallback = handlers['cache-handler-default']
+  return {
+    ...config,
+    ...(handler ? { cacheHandler: handler } : {}),
+    ...(fallback
+      ? { cacheHandlers: { ...(config.cacheHandlers as object), default: fallback } }
+      : {}),
+  }
+}
+
+const toPosix = (file: string) => file.split(path.sep).join('/')
+
 function bundleConfig({
   configPath,
   root,
   outDir,
   outfile,
   cjs,
+  relocatable = false,
 }: {
   configPath: string
   root: string
   outDir: string
   outfile: string
   cjs: boolean
+  /** A release bundle: locate the config from the bundle itself, never from the build machine's paths. */
+  relocatable?: boolean
 }) {
+  const configUrl = relocatable
+    ? `new URL(${JSON.stringify(toPosix(path.relative(outDir, configPath)))}, ${cjs ? '__pnextNodeRequire("node:url").pathToFileURL(__filename)' : 'import.meta.url'}).href`
+    : JSON.stringify(pathToFileURL(configPath).href)
   return build({
     entryPoints: [configPath],
     outfile,
@@ -220,12 +319,20 @@ function bundleConfig({
       ? {
           js:
             'var __pnextNodeRequire = module.require.bind(module);\n' +
-            `var require = __pnextNodeRequire("node:module").createRequire(${JSON.stringify(pathToFileURL(configPath).href)});`,
+            `var __pnextConfigUrl = ${configUrl};\n` +
+            'var __pnextConfigFile = __pnextNodeRequire("node:url").fileURLToPath(__pnextConfigUrl);\n' +
+            'var __pnextConfigDir = __pnextNodeRequire("node:path").dirname(__pnextConfigFile);\n' +
+            'var require = __pnextNodeRequire("node:module").createRequire(__pnextConfigUrl);',
         }
       : {
           js:
             'import { createRequire as __pnextCreateRequire } from "node:module";\n' +
-            `const require = __pnextCreateRequire(${JSON.stringify(pathToFileURL(configPath).href)});`,
+            'import { fileURLToPath as __pnextFileURLToPath } from "node:url";\n' +
+            'import { dirname as __pnextDirname } from "node:path";\n' +
+            `const __pnextConfigUrl = ${configUrl};\n` +
+            'const __pnextConfigFile = __pnextFileURLToPath(__pnextConfigUrl);\n' +
+            'const __pnextConfigDir = __pnextDirname(__pnextConfigFile);\n' +
+            'const require = __pnextCreateRequire(__pnextConfigUrl);',
         },
     // Relative/absolute imports (incl. .ts/.cts/.mts/.cjs/.mjs and tsconfig
     // `paths` aliases) are bundled in. esbuild reads `paths`/`extends` and
@@ -235,9 +342,9 @@ function bundleConfig({
     // import.meta.url in ESM configs (node-api-esm) must point at the config's
     // original location, not the emitted file under .pnext/config.
     define: {
-      __dirname: JSON.stringify(path.dirname(configPath)),
-      __filename: JSON.stringify(configPath),
-      'import.meta.url': JSON.stringify(pathToFileURL(configPath).href),
+      __dirname: '__pnextConfigDir',
+      __filename: '__pnextConfigFile',
+      'import.meta.url': '__pnextConfigUrl',
     },
     logLevel: 'silent',
     sourcemap: false,
@@ -381,6 +488,9 @@ function mapOverrides(config: NextConfigObject): NextConfigCoreOverrides {
     config.output !== 'export'
   ) {
     overrides.outDir = config.distDir
+  } else if (config.output === 'standalone') {
+    // Next's `.next/standalone`: the folder its standalone contract names.
+    overrides.outDir = '.next'
   }
   return overrides
 }
@@ -647,20 +757,36 @@ function validateDevIndicatorPosition(config: NextConfigObject): void {
  */
 export async function loadNextConfig(
   root: string,
-  options: { dev?: boolean; serve?: boolean; warnings?: boolean } = {},
+  options: {
+    dev?: boolean
+    serve?: boolean
+    warnings?: boolean
+    bundle?: string | null
+    handlers?: Record<string, string>
+  } = {},
 ): Promise<LoadNextConfigResult> {
-  const configPath = findConfigPath(root)
+  // A production server names its compiled config, or null when the app had none.
+  storeReleased = options.bundle !== undefined
+  const configPath = options.bundle === undefined ? findConfigPath(root) : options.bundle
   if (!configPath) {
     setNextConfig({})
     emitSessionStartedTelemetry({})
     return { config: {}, overrides: {} }
   }
+  if (options.bundle && !existsSync(options.bundle)) {
+    // The release names this file; serving defaults in its place would drop headers, redirects and more.
+    throw new Error(
+      `pnext: the build's compiled next.config (${options.bundle}) is missing. Run 'pnext build' again.`,
+    )
+  }
   let exported: NextConfigExport
   try {
-    exported = await importConfigModule(configPath, root, {
-      dev: Boolean(options.dev),
-      serve: Boolean(options.serve),
-    })
+    exported = options.bundle
+      ? await importConfigBundle(options.bundle, options.bundle.endsWith('.cjs'))
+      : await importConfigModule(configPath, root, {
+          dev: Boolean(options.dev),
+          serve: Boolean(options.serve),
+        })
   } catch (error) {
     // A next.config that pulls in an optional wrapper dependency not installed
     // in this app (e.g. @next/mdx when deps are declared but not installed)
@@ -677,10 +803,11 @@ export async function loadNextConfig(
     }
     throw error
   }
-  const config = normalizeCacheHandlerPath(
+  const resolved = normalizeCacheHandlerPath(
     await resolveConfigExport(exported, Boolean(options.dev)),
     root,
   )
+  const config = options.bundle ? releasedCacheHandlers(resolved, options.handlers ?? {}) : resolved
   // Internal build workers need the resolved config but must not surface a
   // second copy of CLI warnings already emitted by the owning build process.
   validateConfig(config, configPath, options.warnings !== false)

package/src/compat/next/dynamic.tsx

@@ -1,6 +1,5 @@
 /** @jsxImportSource preact */
 import { h, type ComponentType } from 'preact'
-import { lazy, Suspense } from 'preact/compat'
 import {
   dynamic as pnextDynamic,
   dynamicReferenceSymbol,
@@ -19,25 +18,17 @@ export default function dynamic<Props extends object = object>(
   // Injected by the server compile; see rewriteDynamicCallTargets.
   target?: DynamicTarget,
 ) {
-  if (typeof loader === 'string') return pnextDynamic(loader, options, target)
-
   const coreDynamic = pnextDynamic(loader, options, target) as DynamicWithReference<Props>
-  const Lazy = lazy(() => loader().then(module => ({ default: componentFromModule(module) })))
-  const DynamicComponent = ((props: Props) => {
-    const Loading = options.loading
-    // ssr:false renders nothing on the server, so the client mount is a *hydration* whose only child
-    // suspends. preact/compat nulls a hydrating vnode's type when it unmounts, and Suspense reuses the
-    // same props.children vnode on its resolve re-render - the poisoned element then renders as text.
-    // The hooks-based core component loads without suspending, so that boundary is never entered.
-    if (options.ssr === false) {
-      return h(
-        'pnext-dynamic',
-        { style: { display: 'contents' } },
-        !process.browser && typeof window === 'undefined' ? null : h(coreDynamic, props),
-      )
-    }
-    return h(Suspense, { fallback: Loading ? h(Loading, props) : null }, h(Lazy, props))
-  }) as DynamicWithReference<Props>
+  // Core's component server-renders and hydrates like Next, waiting for a chunk still loading.
+  if (typeof loader === 'string' || options.ssr !== false) return coreDynamic
+
+  // ssr:false renders nothing on the server; the client renders `loading`, then the component.
+  const DynamicComponent = ((props: Props) =>
+    h(
+      'pnext-dynamic',
+      { style: { display: 'contents' } },
+      !process.browser && typeof window === 'undefined' ? null : h(coreDynamic, props),
+    )) as DynamicWithReference<Props>
 
   DynamicComponent[dynamicReferenceSymbol] = coreDynamic[dynamicReferenceSymbol]
   return DynamicComponent
@@ -48,7 +39,3 @@ export { dynamic }
 type DynamicWithReference<Props extends object> = ComponentType<Props> & {
   [dynamicReferenceSymbol]?: DynamicReference<Props>
 }
-
-function componentFromModule<Props>(module: DynamicModule<Props>) {
-  return typeof module === 'function' ? module : module.default
-}

package/src/compat/next/font/cache.ts

@@ -15,6 +15,7 @@ import { restartCacheEnabled } from '../../../dev/restart/enabled'
 import { frameworkFingerprint } from '../../../runtime/fingerprint'
 import { writeFileAtomic } from '../../../utils/fs'
 import type { MetadataLink } from '../../../types'
+import { outCachePath } from '../../../out-paths'
 
 export interface PersistableFont {
   css: string
@@ -54,7 +55,7 @@ interface FontIndex {
 const indexes = new Map<string, FontIndex>()
 
 function fontIndex(config: ResolvedConfig): FontIndex {
-  const file = path.join(config.outPath, 'cache', 'fonts', 'index.json')
+  const file = path.join(outCachePath(config.outPath), 'fonts', 'index.json')
   const existing = indexes.get(file)
   if (existing) return existing
   const created: FontIndex = { file, fonts: readIndex(file), dirty: false }

package/src/compat/next/font/runtime.ts

@@ -8,6 +8,7 @@ import { fileURLToPath } from 'node:url'
 import type { ResolvedConfig } from '../../../config'
 import { onExtensionHostReset, registerResponseFinalizers } from '../../../extensions'
 import { getWorkUnit } from '../../../request/context'
+import { servedRelease } from '../../../runtime/production'
 import type { MetadataLink } from '../../../types'
 import { persistFont, persistedFont } from './cache'
 import { escapeRegex } from '../../../utils/code'
@@ -383,7 +384,23 @@ function registerFont(definition: FontDefinition) {
   fontStorage.getStore()?.fonts.set(definition.key, definition)
 }
 
-async function resolveFont(definition: FontDefinition, context: FontResolveContext) {
+/** Every declared font, resolved for a release (its files emitted under the out dir). */
+export async function releaseFonts(config: ResolvedConfig): Promise<Record<string, ResolvedFont>> {
+  const fonts: Record<string, ResolvedFont> = {}
+  for (const font of declaredFonts.values()) {
+    const { sources: _sources, ...resolved } = await resolveFont(font, { config })
+    fonts[font.key] = resolved
+  }
+  return fonts
+}
+
+async function resolveFont(
+  definition: FontDefinition,
+  context: FontResolveContext,
+): Promise<ResolvedFont> {
+  // A production release serves the build's resolution: font sources are not read at request time.
+  const released = servedRelease()?.fonts?.[definition.key]
+  if (released) return released
   const key = `${context.config.outPath}:${context.dev ? 'dev' : 'build'}:${definition.key}`
   let resolved = resolvedFontCache.get(key)
   if (!resolved) {
@@ -506,7 +523,10 @@ async function resolveLocalFont(
     ? false
     : true
   const preload = request.options.preload !== false
-  const sources = normalizeLocalSources(request.options, request.callerFile)
+  const sources = normalizeLocalSources(
+    request.options,
+    request.callerFile && path.resolve(context.config.root, request.callerFile),
+  )
   const emitted = await Promise.all(
     sources.map(async source => ({
       ...source,
@@ -785,7 +805,7 @@ async function emitFontBytes(
   // Served from `/_next/static/media/` — files under the out dir's public/ map 1:1 to the URL path,
   // which is the only place dev and build both look them up.
   const mediaSegments = ['_next', 'static', 'media']
-  const outDir = path.join(context.config.outPath, 'public', ...mediaSegments)
+  const outDir = path.join(context.config.outPath, 'static', ...mediaSegments)
   const file = path.join(outDir, filename)
   const asset = {
     ext,

package/src/compat/next/og.ts

@@ -134,13 +134,13 @@ async function renderWithSatori(
   element: unknown,
   options: ImageResponseOptions,
 ): Promise<Uint8Array | undefined> {
+  // Fonts first: without one satori cannot lay out text, so loading it would be wasted work.
+  const fonts = normalizeFonts(options.fonts)
+  if (fonts.length === 0) return undefined
   const satori = await loadOptional<SatoriModule>('satori')
   const resvg = await loadOptional<ResvgModule>('@resvg/resvg-js')
   if (!satori || !resvg) return undefined
 
-  const fonts = normalizeFonts(options.fonts)
-  if (fonts.length === 0) return undefined
-
   const width = dimension(options.width, DEFAULT_WIDTH, 'width')
   const height = dimension(options.height, DEFAULT_HEIGHT, 'height')
 

package/src/compat/next/usage.ts

@@ -1,5 +1,6 @@
-import { existsSync, readdirSync, readFileSync, type Dirent } from 'node:fs'
+import { existsSync, readdirSync, type Dirent } from 'node:fs'
 import path from 'node:path'
+import { readSourceSync } from '../../resolve/source-text'
 
 /**
  * Build-time app facts that let compat drop code an app cannot reach. The fact here: whether any
@@ -95,7 +96,7 @@ function scan(dir: string, match: (source: string) => boolean): boolean {
     if (!sourceFile.test(entry.name)) continue
     let source: string
     try {
-      source = readFileSync(file, 'utf8')
+      source = readSourceSync(file)
     } catch {
       continue
     }

package/src/compat/pages/api.ts

@@ -2,15 +2,19 @@
 // shims plus the API-route and data-fetch (`/_next/data`) dispatch. Registered by
 // ../register/pages-api.ts, which wires the exports below into the extension registries.
 
-import { existsSync, readFileSync } from 'node:fs'
+import { type Dirent, existsSync, readFileSync, readdirSync } from 'node:fs'
 import { Writable } from 'node:stream'
 import path from 'node:path'
-import { devServerModuleHref } from '../../runtime/modules'
-import { pagesApiBundleTargetForRuntime } from '../../runtime/loader'
+import {
+  devServerModuleHref,
+  pagesApiBundleTargetForRuntime,
+  serverBundleTargetForRuntime,
+} from '../../runtime/load'
+import { productionRelease } from '../../runtime/production'
+import type { ResolvedConfig } from '../../config'
 import { getRequestExtensions, type RequestInterceptor } from '../../extensions'
 import { getRequestRuntime } from '../../routing/request-environment'
-import { selectRouteForRequest } from '../../routing/routes'
-import { serverBundleTargetForRuntime } from '../../runtime/loader'
+import { selectRouteForRequest } from '../../routing/match'
 import { setWorkUnitRoute } from '../../request/context'
 import { canonicalUrlHref } from '../next/canonical-url'
 import { markPathRevalidated, normalizeRevalidatePath } from '../cache/revalidate'
@@ -65,7 +69,7 @@ export const pagesDataInterceptor: RequestInterceptor = async request => {
     return dataResponse({ notFound: true }, 404, url)
   }
   const route = selection.route
-  if (!isMaterializedPagesRoute(route.file)) return undefined
+  if (!isMaterializedPagesRoute(runtime.config, route.file)) return undefined
 
   const module = (await import(
     await devServerModuleHref(
@@ -150,8 +154,19 @@ function dataResponse(body: Record<string, unknown>, status: number, url: URL):
 
 // The materialized hybrid app hosts BOTH routers; only pages wrappers
 // re-export from source-pages/, so sniff the (tiny, generated) wrapper body —
-// app routes must never serve _next/data.
-function isMaterializedPagesRoute(file: string): boolean {
+// app routes must never serve _next/data. A release carries the answer.
+const releasedPagesRoutes = new WeakMap<object, Set<string>>()
+
+export function isMaterializedPagesRoute(config: ResolvedConfig, file: string): boolean {
+  const released = productionRelease(config)?.compat?.pagesRoutes
+  if (released) {
+    let routes = releasedPagesRoutes.get(released)
+    if (!routes) {
+      routes = new Set(released.map(route => path.join(config.root, route)))
+      releasedPagesRoutes.set(released, routes)
+    }
+    return routes.has(file)
+  }
   if (!file.split(path.sep).join('/').includes('pnext-pages-compat/')) return false
   try {
     return readFileSync(file, 'utf8').includes('source-pages/')
@@ -160,6 +175,29 @@ function isMaterializedPagesRoute(file: string): boolean {
   }
 }
 
+/** The materialized pages-router wrappers of a pages-compat app, root-relative, for its release. */
+export function pagesRouteFacts(config: ResolvedConfig): string[] {
+  if (!config.appPath.includes('pnext-pages-compat')) return []
+  const routes: string[] = []
+  const visit = (dir: string) => {
+    let entries: Dirent[]
+    try {
+      entries = readdirSync(dir, { withFileTypes: true })
+    } catch {
+      return
+    }
+    for (const entry of entries) {
+      const file = path.join(dir, entry.name)
+      if (entry.isDirectory()) visit(file)
+      else if (isMaterializedPagesRoute(config, file)) {
+        routes.push(path.relative(config.root, file).split(path.sep).join('/'))
+      }
+    }
+  }
+  visit(config.appPath)
+  return routes
+}
+
 function pagesDataRequestShim(request: Request, url: URL) {
   return {
     method: request.method,
@@ -194,11 +232,16 @@ function pagesDataResponseShim() {
 
 export const pagesApiInterceptor: RequestInterceptor = async (request, { config }) => {
   const url = new URL(request.url)
-  const file = pagesApiFile(config.root, url.pathname)
+  const released = productionRelease(config)?.compat?.pagesApi
+  const exists = released
+    ? (candidate: string) => path.relative(config.root, candidate) in released
+    : existsSync
+  const file = pagesApiFile(config.root, url.pathname, exists)
   if (!file) return undefined
+  const runtime = released ? released[path.relative(config.root, file)] : apiRuntime(file)
   const imported = (await import(
     await devServerModuleHref(config, file, 'build', {
-      conditionTarget: pagesApiBundleTargetForRuntime(apiRuntime(file)),
+      conditionTarget: pagesApiBundleTargetForRuntime(runtime),
     })
   )) as PagesApiModule
   if (typeof imported.default !== 'function') return undefined
@@ -208,7 +251,7 @@ export const pagesApiInterceptor: RequestInterceptor = async (request, { config
   // nextUrl, text() — Request prototype getters a spread would lose); node
   // handlers get the IncomingMessage-shaped shim.
   const handlerRequest =
-    apiRuntime(file) === 'edge' ? toNextRequest(request) : createPagesApiRequest(request, url)
+    runtime === 'edge' ? toNextRequest(request) : createPagesApiRequest(request, url)
   const finished = withPagesApiHandlerSpan(url.pathname, () =>
     Promise.resolve(imported.default!(handlerRequest, responder.res)),
   ).catch(error => responder.fail(error))
@@ -226,7 +269,33 @@ export const pagesApiInterceptor: RequestInterceptor = async (request, { config
 
 const STREAM_STARTED = Symbol('pnext.pagesApiStreamStarted')
 
-function pagesApiFile(root: string, pathname: string): string | undefined {
+/** Every pages API source with its runtime (`nodejs` unless declared), root-relative: what a release serves. */
+export function pagesApiFacts(root: string): Record<string, string> {
+  const facts: Record<string, string> = {}
+  const visit = (dir: string) => {
+    let entries: Dirent[]
+    try {
+      entries = readdirSync(dir, { withFileTypes: true })
+    } catch {
+      return
+    }
+    for (const entry of entries) {
+      const file = path.join(dir, entry.name)
+      if (entry.isDirectory()) visit(file)
+      else if (pageExtensions.some(ext => entry.name.endsWith(`.${ext}`))) {
+        facts[path.relative(root, file)] = apiRuntime(file) ?? 'nodejs'
+      }
+    }
+  }
+  visit(path.join(root, 'pages', 'api'))
+  return facts
+}
+
+function pagesApiFile(
+  root: string,
+  pathname: string,
+  exists: (file: string) => boolean,
+): string | undefined {
   if (pathname !== '/api' && !pathname.startsWith('/api/')) return undefined
   let relative: string
   try {
@@ -239,9 +308,9 @@ function pagesApiFile(root: string, pathname: string): string | undefined {
   if (base !== baseDir && !base.startsWith(`${baseDir}${path.sep}`)) return undefined
   for (const ext of pageExtensions) {
     const file = `${base}.${ext}`
-    if (existsSync(file)) return file
+    if (exists(file)) return file
     const index = path.join(base, `index.${ext}`)
-    if (existsSync(index)) return index
+    if (exists(index)) return index
   }
   return undefined
 }