@wular/pnext 0.1.5 → 0.1.7

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,
@@ -647,20 +754,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 +800,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/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,

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
 }

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/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 =>