@wular/pnext 0.1.6 → 0.1.8

package/src/compat/pages/router.ts

@@ -57,7 +57,10 @@ function isAppConvention(name: string): boolean {
  * outside the source app preserves native App routes and avoids hybrid-route
  * conflict validation; linked sources and node_modules keep normal resolution.
  */
-export async function materializePagesApp(root: string): Promise<string | undefined> {
+export async function materializePagesApp(
+  root: string,
+  base = path.join(tmpdir(), 'pnext-pages-compat'),
+): Promise<string | undefined> {
   const pagesPath = path.join(root, 'pages')
   if (!existsSync(pagesPath)) return undefined
 
@@ -71,11 +74,7 @@ export async function materializePagesApp(root: string): Promise<string | undefi
   // one shared directory let one process scan a half-materialized tree ("page.js doesn't have a root
   // layout" on a build that passes on the next run). Naming the directory after what goes in it makes
   // the second writer a no-op, and staging + rename means a reader sees the whole tree or nothing.
-  const generatedRoot = path.join(
-    tmpdir(),
-    'pnext-pages-compat',
-    materializationKey(root, nativeApp, pages, apiRoutes),
-  )
+  const generatedRoot = path.join(base, materializationKey(root, nativeApp, pages, apiRoutes))
   const appPath = path.join(generatedRoot, 'app')
   if (existsSync(appPath)) return appPath
 
@@ -88,10 +87,20 @@ export async function materializePagesApp(root: string): Promise<string | undefi
     await rm(staging, { recursive: true, force: true })
     if (!existsSync(appPath)) throw new Error(`pnext: could not materialize ${root}/pages`)
   }
-  void sweepStaleMaterializations(path.dirname(generatedRoot))
+  void sweepStaleMaterializations(
+    base,
+    isInsideApp(root, generatedRoot) ? path.basename(generatedRoot) : undefined,
+  )
   return appPath
 }
 
+const isInsideApp = (root: string, dir: string) => !path.relative(root, dir).startsWith('..')
+
+/** A materialized tree's link to app source: relative when the tree lives inside the app. */
+function materializedLinkTarget(root: string, generatedRoot: string, target: string) {
+  return isInsideApp(root, generatedRoot) ? path.relative(generatedRoot, target) : target
+}
+
 /**
  * Everything the materialized tree is derived from: the pages facts (already parsed out of the
  * sources), the native app tree's shape, and this module — whose `wrapperSource` writes the files.
@@ -134,10 +143,12 @@ function materializationKey(
 // a dev server holds its materialized tree open for as long as it runs.
 const STALE_MATERIALIZATION_MS = 7 * 24 * 60 * 60_000
 
-async function sweepStaleMaterializations(base: string) {
+// A build's own output keeps only its `current` tree: nothing else serves from it.
+async function sweepStaleMaterializations(base: string, current?: string) {
   try {
-    const cutoff = Date.now() - STALE_MATERIALIZATION_MS
+    const cutoff = current ? Infinity : Date.now() - STALE_MATERIALIZATION_MS
     for (const entry of await readdir(base)) {
+      if (current && (entry === current || entry.endsWith('.staging'))) continue
       const dir = path.join(base, entry)
       const info = statSync(dir, { throwIfNoEntry: false })
       if (info && info.mtimeMs < cutoff) await rm(dir, { recursive: true, force: true })
@@ -158,23 +169,28 @@ async function buildMaterializedApp(
   const appPath = path.join(generatedRoot, 'app')
   const sourcePages = path.join(generatedRoot, 'source-pages')
   const sourceApp = path.join(generatedRoot, 'source-app')
+  // Inside a build's output the links stay relative, so a moved build names no build-machine path.
+  const link = (target: string, at: string) =>
+    symlink(materializedLinkTarget(root, generatedRoot, target), at, 'dir')
 
   await rm(generatedRoot, { recursive: true, force: true })
   await mkdir(appPath, { recursive: true })
-  await symlink(pagesPath, sourcePages, 'dir')
+  await link(pagesPath, sourcePages)
+  // Inside the app, packages resolve up to the app's own node_modules under their real paths.
   const nodeModules = path.join(root, 'node_modules')
-  if (existsSync(nodeModules))
-    await symlink(nodeModules, path.join(generatedRoot, 'node_modules'), 'dir')
+  if (existsSync(nodeModules) && !isInsideApp(root, generatedRoot)) {
+    await link(nodeModules, path.join(generatedRoot, 'node_modules'))
+  }
 
   // Static assets referenced from materialized routes (e.g. an app route's
   // `new URL('../../public/vercel.png', import.meta.url)` or a `public/*` asset
   // import) resolve relative to the generated root; without the symlink the
   // bundler can't find them and the route 500s.
   const publicDir = path.join(root, 'public')
-  if (existsSync(publicDir)) await symlink(publicDir, path.join(generatedRoot, 'public'), 'dir')
+  if (existsSync(publicDir)) await link(publicDir, path.join(generatedRoot, 'public'))
 
   if (existsSync(nativeApp)) {
-    await symlink(nativeApp, sourceApp, 'dir')
+    await link(nativeApp, sourceApp)
     await materializeNativeApp(sourceApp, appPath)
   }
   if (!existsSync(path.join(appPath, 'layout.js'))) {

package/src/compat/register/bundler.ts

@@ -46,7 +46,7 @@ import {
   setResolveExtensions,
   setTsConfigPath,
 } from '../../resolve/imports'
-import { setServerBundleConditions } from '../../runtime/loader'
+import { setServerBundleConditions } from '../../runtime/load'
 import { escapeRegex, specifierSniffTokens } from '../../utils/code'
 import {
   cacheComponentsEnabled,
@@ -59,6 +59,7 @@ import {
   relayCompilerConfig,
   removeConsoleTargets,
   resolveExtensions,
+  builtInServerExternalPackages,
   serverExternalPackages,
   swcEnvUsageMode,
   tsconfigPath,
@@ -160,6 +161,7 @@ export function registerBundlerExtensions(config: ResolvedConfig): void {
     // Linked workspace packages are deliberately absent: esbuild resolves their
     // symlinks to real paths, so they never reach a filter as node_modules.
     transpiled: () => [...transpile].filter(name => !externals.has(name)),
+    releaseExternal: name => builtInServerExternalPackages().has(name) && !transpile.has(name),
     esmExternals,
   })
   setExternalLoadResolver(({ root, fromFile, specifier, target }) => {

package/src/compat/register/image.ts

@@ -122,7 +122,7 @@ async function writeImagesManifestStep(ctx: BuildStepContext): Promise<void> {
 async function mirrorStaticMedia(config: ResolvedConfig): Promise<void> {
   const { cp } = await import('node:fs/promises')
   for (const dir of ['media', 'immutable/media']) {
-    const source = path.join(config.outPath, 'public', '_next', 'static', dir)
+    const source = path.join(config.outPath, 'static', '_next', 'static', dir)
     const target = path.join(config.root, '.next', 'static', dir)
     try {
       await cp(source, target, { recursive: true, force: true })

package/src/compat/register/middleware.ts

@@ -14,7 +14,7 @@ import {
   type ProxyConfig,
   type ProxyModule,
 } from '../../routing/proxy'
-import { devServerModuleHref } from '../../runtime/modules'
+import { devServerModuleHref } from '../../runtime/load'
 import { pathToFileHref, type ResolvedConfig } from '../../config'
 import { toPosixPath } from '../../utils/fs'
 import type { RouteManifestEntry } from '../../types'

package/src/compat/register/otel.ts

@@ -14,8 +14,7 @@
 // opentelemetry suite. Everything is inert unless next compat is on AND @opentelemetry/api resolves from
 // the app.
 
-import { readFileSync } from 'node:fs'
-import path from 'node:path'
+import { isMaterializedPagesRoute } from '../pages/api'
 import type { ResolvedConfig } from '../../config'
 import type { RouteManifestEntry } from '../../types'
 import {
@@ -30,7 +29,7 @@ import {
 } from '../../extensions'
 import { nextCompatEnabled } from '../aliases'
 import { getRequestRuntime } from '../../routing/request-environment'
-import { selectRouteForRequest } from '../../routing/routes'
+import { selectRouteForRequest } from '../../routing/match'
 import { queueAfterTask } from '../../request/context'
 import {
   getDocumentScriptExtensions,
@@ -247,14 +246,11 @@ function routeEntryFor(routePattern: string): RouteManifestEntry | undefined {
 // stable generator-owned marker; cache per file (routes don't change at start).
 const pagesCompatFileCache = new Map<string, boolean>()
 function isPagesCompatEntry(entry: RouteManifestEntry | undefined): boolean {
-  if (!entry?.file.includes(`${path.sep}pnext-pages-compat${path.sep}`)) return false
+  const config = getRequestRuntime()?.config
+  if (!entry || !config) return false
   let cached = pagesCompatFileCache.get(entry.file)
   if (cached === undefined) {
-    try {
-      cached = readFileSync(entry.file, 'utf8').includes('source-pages/')
-    } catch {
-      cached = false
-    }
+    cached = isMaterializedPagesRoute(config, entry.file)
     pagesCompatFileCache.set(entry.file, cached)
   }
   return cached

package/src/compat/register/render.ts

@@ -32,7 +32,7 @@ import {
   setStreamRouteExtensions,
   setSuspenseExtensions,
 } from '../../render/hooks'
-import { withAssetPrefix } from '../../css/build'
+import { withAssetPrefix } from '../../css/assets'
 import { polyfillsChunkPath } from '../bundler/polyfill'
 import { nextRouterShimScript } from '../react/router-shim'
 import { renderPartytownHeadScripts } from '../next/script'
@@ -43,6 +43,7 @@ import {
   fontPreloadDomScript,
   fontSizeAdjustMeta,
   prewarmFonts,
+  releaseFonts,
   runWithFontScope,
 } from '../next/font/runtime'
 import {
@@ -117,6 +118,7 @@ export function registerRenderExtensions(config: ResolvedConfig): void {
       runWithFontScope,
       collectFontAssets: fontAssets,
       prewarmFontAssets: prewarmFonts,
+      releaseFonts,
     })
     setDocumentScriptExtensions({
       documentBodyScripts: cfg =>

package/src/compat/register/use-cache.ts

@@ -14,6 +14,7 @@
 // lazy-static MISS responses. Emitting it for pure static HITs needs the route's cacheLife persisted in
 // the build manifest and read by the static-serve path in src/cli/start.ts.
 
+import { productionRelease } from '../../runtime/production'
 import type { ResolvedConfig } from '../../config'
 import { nextCompatEnabled } from '../../compat/aliases'
 import {
@@ -84,7 +85,8 @@ export function registerUseCacheExtensions(config: ResolvedConfig): void {
   // Seed the root-param NAME set for cache-key participation (Stage B-3): a
   // `use cache` entry's conservative first-call key may only discriminate by
   // root params, so the runtime needs the scanned names at build AND serve.
-  setUseCacheRootParamNames(scanRootParams(config.appPath))
+  const released = productionRelease(config)?.compat?.rootParams
+  setUseCacheRootParamNames(released ? new Set(released) : scanRootParams(config.appPath))
 
   // Arm `use cache` build-time validation for this build's prerender pass.
   // Registered as a build STEP so it runs before any page is prerendered; the

package/src/compat/release.ts

@@ -0,0 +1,46 @@
+// Compat facts a production release carries (COMPAT): compiled next.config, cache handlers and
+// instrumentation, plus the app facts compat would otherwise rescan from source at boot.
+import path from 'node:path'
+import type { ResolvedConfig } from '../config'
+import type { CompatRelease } from '../runtime/production'
+import { pagesRevalidateFacts } from './cache-control'
+import { emitReleaseInstrumentation } from './lifecycle/instrumentation'
+import { emitNextConfigBundle } from './next/config-loader'
+import { pagesApiFacts, pagesRouteFacts } from './pages/api'
+import { scanRootParams } from './ppr/root-params-scan'
+
+export async function compatReleaseFacts(
+  config: ResolvedConfig,
+  outDir: string,
+): Promise<CompatRelease> {
+  const [nextConfig, instrumentation] = await Promise.all([
+    emitNextConfigBundle(config.root, outDir),
+    emitReleaseInstrumentation(config, outDir),
+  ])
+  const toPosix = (file: string) => file.split(path.sep).join('/')
+  return {
+    ...(nextConfig ? { nextConfig: toPosix(path.relative(config.outPath, nextConfig.file)) } : {}),
+    ...(instrumentation
+      ? {
+          instrumentation: {
+            file: toPosix(instrumentation.file),
+            ...(instrumentation.edge ? { edge: toPosix(instrumentation.edge) } : {}),
+          },
+        }
+      : {}),
+    compat: {
+      rootParams: [...scanRootParams(config.appPath)],
+      pagesRevalidate: pagesRevalidateFacts(config.root).map(
+        ([file, seconds]): [string, number] => [toPosix(file), seconds],
+      ),
+      pagesApi: pagesApiFacts(config.root),
+      pagesRoutes: pagesRouteFacts(config),
+      cacheHandlers: Object.fromEntries(
+        Object.entries(nextConfig?.handlers ?? {}).map(([name, file]) => [
+          name,
+          toPosix(path.relative(config.outPath, file)),
+        ]),
+      ),
+    },
+  }
+}

package/src/compat/segment/serve.ts

@@ -30,7 +30,7 @@ import {
 } from '../../extensions'
 import { getRequestRuntime } from '../../routing/request-environment'
 import { takeCacheLifeStash } from '../cache/use-cache'
-import { matchInterception, parseNavState, selectRouteForRequest } from '../../routing/routes'
+import { matchInterception, parseNavState, selectRouteForRequest } from '../../routing/match'
 import {
   currentPprShellHtml,
   pprShellPath,

package/src/compat/typecheck/check.ts

@@ -42,6 +42,7 @@ export function typecheckDisabled(): boolean {
 export interface TypecheckWorkerInput {
   root: string
   outPath: string
+  outRootPath: string
   compat: ResolvedConfig['compat']
   nextConfig: NextConfigObject
 }
@@ -64,6 +65,7 @@ export async function validateTypesOffThread(config: ResolvedConfig): Promise<vo
   const input: TypecheckWorkerInput = {
     root: config.root,
     outPath: config.outPath,
+    outRootPath: config.outRootPath,
     compat: config.compat,
     nextConfig: cloneable({
       typescript: next.typescript,
@@ -210,12 +212,12 @@ function appDiagnostic(file: string | undefined, config: ResolvedConfig): boolea
   if (resolved === generatedProjectPath(config)) return true
   if (!resolved.startsWith(config.root + path.sep)) return false
   if (resolved.includes(`${path.sep}node_modules${path.sep}`)) return false
-  if (resolved.startsWith(path.resolve(config.outPath) + path.sep)) return false
+  if (resolved.startsWith(path.resolve(config.outRootPath) + path.sep)) return false
   return true
 }
 
 function generatedProjectPath(config: ResolvedConfig): string {
-  return path.resolve(config.outPath, 'typecheck', 'tsconfig.json')
+  return path.resolve(config.outRootPath, 'typecheck', 'tsconfig.json')
 }
 
 /**
@@ -292,7 +294,7 @@ async function writeTypecheckProject(
   config: ResolvedConfig,
   native: string | undefined,
 ): Promise<string> {
-  const dir = path.join(config.outPath, 'typecheck')
+  const dir = path.join(config.outRootPath, 'typecheck')
   await mkdir(dir, { recursive: true })
   const reactTypes = resolveTypesDir('react', config.root)
   const hasReactTypes = reactTypes !== undefined
@@ -420,7 +422,7 @@ async function writeTypecheckProject(
 }
 
 function preactTypeShimPath(config: ResolvedConfig): string {
-  return path.join(config.outPath, 'typecheck', 'preact-compat.d.ts')
+  return path.join(config.outRootPath, 'typecheck', 'preact-compat.d.ts')
 }
 
 function preactTypeShim(preact: string, react: string): string {

package/src/compat/validation/validate.ts

@@ -10,8 +10,9 @@
 // undefined/non-component default export; and the output:'export' extras (exportPathMap + app, a
 // dynamic route without generateStaticParams, route handlers without static opt-ins, force-dynamic).
 
-import { existsSync, readdirSync, readFileSync } from 'node:fs'
+import { existsSync, readdirSync } from 'node:fs'
 import path from 'node:path'
+import { readSourceSync } from '../../resolve/source-text'
 import type { ResolvedConfig } from '../../config'
 import { extraPageExtensions } from '../../extensions'
 import type { RouteManifestEntry } from '../../types'
@@ -366,7 +367,7 @@ function readSource(file: string): string | undefined {
   if (sourceCache.has(file)) return sourceCache.get(file)
   let source: string | undefined
   try {
-    source = readFileSync(file, 'utf8')
+    source = readSourceSync(file)
   } catch {
     source = undefined
   }
@@ -379,7 +380,12 @@ function routeFiles(route: RouteManifestEntry): string[] {
 }
 
 function isAppSourceFile(config: ResolvedConfig, file: string): boolean {
-  if (isInside(config.outPath, file)) return false
+  const materialized =
+    file.includes(`${path.sep}source-app${path.sep}`) ||
+    file.includes(`${path.sep}source-pages${path.sep}`)
+  // A build materializes pages sources into its output (`<out>/pnext-pages-compat`).
+  if (isInside(config.outPath, file))
+    return materialized && file.includes(`${path.sep}pnext-pages-compat${path.sep}`)
   const relative = path.relative(config.root, file)
   if (relative !== '' && !relative.startsWith('..') && !path.isAbsolute(relative)) {
     // A standalone npm layout keeps node_modules INSIDE the root; framework-supplied route
@@ -387,10 +393,7 @@ function isAppSourceFile(config: ResolvedConfig, file: string): boolean {
     // (a JSDoc example in pnext's extensions.ts failed a real app's build as './pic.png').
     return !relative.split(path.sep).includes('node_modules')
   }
-  return (
-    file.includes(`${path.sep}source-app${path.sep}`) ||
-    file.includes(`${path.sep}source-pages${path.sep}`)
-  )
+  return materialized
 }
 
 function isInside(parent: string, file: string): boolean {

package/src/config.ts

@@ -1,11 +1,21 @@
 import { existsSync, realpathSync } from 'node:fs'
 import { fileURLToPath, pathToFileURL } from 'node:url'
 import path from 'node:path'
+import { outCachePath, standaloneOutSegment } from './out-paths'
 import { loadEnv } from './env'
-import { findWorkspaceRoot } from './resolve/imports'
+import { findWorkspaceRoot } from './resolve/package-json'
 import { PREFETCH_MODES, type PNextConfig } from './types'
 import { setCacheComponents } from './render/ppr'
 import { setLegacyRequestAPIs } from './request/context'
+import {
+  attachRelease,
+  buildIndexFile,
+  linkStandaloneOrigins,
+  readBuildIndex,
+  releaseConfig,
+  releaseSourceRoot,
+  servingReleaseDir,
+} from './runtime/production'
 
 export type ResolvedConfig = Required<Pick<PNextConfig, 'outDir' | 'basePath'>> &
   Omit<PNextConfig, 'outDir' | 'basePath'> & {
@@ -15,7 +25,7 @@ export type ResolvedConfig = Required<Pick<PNextConfig, 'outDir' | 'basePath'>>
     publicDir: 'public'
     appPath: string
     publicPath: string
-    /** Where this process writes and serves from: the out root, or `<outRoot>/dev` in dev. */
+    /** Where this process writes and serves from: `<outRoot>/standalone`, or `<outRoot>/dev` in dev. */
     outPath: string
     /** The out root itself (`.pnext`), identical in dev and build. */
     outRootPath: string
@@ -61,7 +71,13 @@ export interface ConfigSourceOverrides {
 }
 export type ConfigSource = (
   root: string,
-  options: { dev?: boolean; serve?: boolean; warnings?: boolean },
+  options: {
+    dev?: boolean
+    serve?: boolean
+    warnings?: boolean
+    bundle?: string | null
+    handlers?: Record<string, string>
+  },
 ) => Promise<ConfigSourceOverrides>
 
 let configSource: ConfigSource | undefined
@@ -73,7 +89,7 @@ export function registerConfigSource(source: ConfigSource): void {
 async function resolveConfigSource(
   config: PNextConfig,
   root: string,
-  options: { dev?: boolean; serve?: boolean; warnings?: boolean },
+  options: Parameters<ConfigSource>[1],
 ): Promise<ConfigSourceOverrides> {
   if (!config.compat?.next) return {}
   if (!configSource) {
@@ -90,6 +106,8 @@ export async function loadConfig(
   options: { dev?: boolean; serve?: boolean; warnings?: boolean } = {},
 ): Promise<ResolvedConfig> {
   const root = canonicalRoot(path.resolve(rootInput))
+  const released = options.serve ? servingReleaseDir() : undefined
+  if (released) return loadReleasedConfig(root, released, options)
   await loadEnv(root, options)
   const configPath = path.join(root, 'pnext.config.ts')
   const loadedConfig = existsSync(configPath)
@@ -119,8 +137,19 @@ export async function loadConfig(
   setCacheComponents(false)
   const sourceOverrides = stripUndefined(await resolveConfigSource(config, root, options))
   const merged = { ...defaultConfig, ...config, ...sourceOverrides }
-  const appPath = await resolveAppPath(root, config)
   const outRootPath = path.resolve(root, merged.outDir)
+  // `pnext start` reads outDir from the config, as `next start` reads distDir, then serves the release.
+  const release = path.join(outRootPath, standaloneOutSegment)
+  if (options.serve && existsSync(buildIndexFile(release))) {
+    // The source config above already warned; its compiled copy must not warn again.
+    return loadReleasedConfig(root, release, { ...options, warnings: false })
+  }
+  // A build materializes pages into its output, so the release names them portably.
+  const appPath = await resolveAppPath(
+    root,
+    config,
+    options.dev ? undefined : path.join(outRootPath, 'pnext-pages-compat'),
+  )
   const workspaceRoot = canonicalRoot(
     config.workspaceRoot
       ? path.resolve(root, config.workspaceRoot)
@@ -149,13 +178,45 @@ export async function loadConfig(
     // Dev owns `<outRoot>/dev` exclusively so a concurrent `pnext build` — which
     // wipes its own outputs under the out root — can never pull a running dev
     // server's cache, manifest or assets out from under it.
-    outPath: options.dev ? path.join(outRootPath, devOutSegment) : outRootPath,
+    outPath: path.join(outRootPath, options.dev ? devOutSegment : standaloneOutSegment),
     outRootPath,
     typesPath: path.join(outRootPath, 'types'),
     checksPath: path.join(outRootPath, 'typecheck', 'checks'),
   }
 }
 
+/**
+ * A production server's config: what the build resolved, read from its release instead of re-importing
+ * `pnext.config.ts`/`next.config.*`. Per-app process state is re-derived exactly as a source load does.
+ */
+async function loadReleasedConfig(
+  root: string,
+  outPath: string,
+  options: { dev?: boolean; serve?: boolean; warnings?: boolean },
+): Promise<ResolvedConfig> {
+  const index = readBuildIndex(outPath)
+  linkStandaloneOrigins(outPath)
+  const sourceRoot = releaseSourceRoot(outPath, index.config.outPath as string)
+  const config = releaseConfig(index.config, sourceRoot, outPath)
+  await loadEnv(root, options)
+  setLegacyRequestAPIs(
+    typeof config.compat?.next === 'object' && config.compat.next.legacyRequestAPIs === true,
+  )
+  setCacheComponents(false)
+  await resolveConfigSource(config, root, {
+    ...options,
+    bundle: index.nextConfig ? path.resolve(outPath, index.nextConfig) : null,
+    handlers: Object.fromEntries(
+      Object.entries(index.compat?.cacheHandlers ?? {}).map(([name, file]) => [
+        name,
+        path.resolve(outPath, file),
+      ]),
+    ),
+  })
+  attachRelease(config, index)
+  return config
+}
+
 // One row per enum-valued config field; validateConfig checks them all.
 const enumFields: readonly [keyof PNextConfig, readonly unknown[]][] = [
   ['prefetch', PREFETCH_MODES],
@@ -175,6 +236,8 @@ function validateConfig(config: PNextConfig) {
 /** Dev's private subtree under the out root. Build never touches it. */
 export const devOutSegment = 'dev'
 
+export { outCachePath, standaloneOutSegment }
+
 // Relative-import resolution realpaths the importing file (so a materialized shim resolves `./sibling`
 // against real source), so every containment check against root/workspaceRoot compares realpaths.
 // Canonicalize the roots to match - otherwise an app served through a symlinked directory (a macOS
@@ -253,6 +316,10 @@ export function frameworkRuntimeAliasEntries(): Record<FrameworkRuntimeAlias, st
   return frameworkRuntimeAliases
 }
 
+/** Packages the framework resolves at runtime by name, not by import. */
+export const frameworkRuntimeSpecifiers = (): string[] =>
+  Object.keys(frameworkRuntimeAliasEntries())
+
 function resolveRuntimeModule(specifier: string) {
   return fileURLToPath(import.meta.resolve(specifier))
 }
@@ -264,7 +331,7 @@ export function pnextAliases(target: CompatAliasTarget): Record<string, string>
   }
 }
 
-async function resolveAppPath(root: string, config: PNextConfig) {
+async function resolveAppPath(root: string, config: PNextConfig, pagesBase?: string) {
   const rootApp = path.join(root, 'app')
   if (config.compat?.next) {
     const pagesPath = path.join(root, 'pages')
@@ -272,13 +339,13 @@ async function resolveAppPath(root: string, config: PNextConfig) {
     if (existsSync(rootApp)) {
       if (hasPages) {
         const { materializePagesApp } = await import('./compat/pages/router')
-        const hybrid = await materializePagesApp(root)
+        const hybrid = await materializePagesApp(root, pagesBase)
         if (hybrid) return hybrid
       }
       return rootApp
     }
     const { materializePagesApp } = await import('./compat/pages/router')
-    const pagesApp = await materializePagesApp(root)
+    const pagesApp = await materializePagesApp(root, pagesBase)
     if (pagesApp) return pagesApp
   } else if (existsSync(rootApp)) return rootApp
   return path.join(root, 'src', 'app')