@wular/pnext 0.1.6 → 0.1.8

package/src/dev/restart/route-facts.ts

@@ -20,6 +20,7 @@ import { setRouteFactsStore, type RouteFacts, type RouteFactsStore } from '../..
 import { traceEnabled } from '../../utils/trace-flags'
 import { restartCacheEnabled } from './enabled'
 import { hash, lazyRecordCacheKey, revalidate, sourceEntry, type SourceEntry } from './record'
+import { outCachePath } from '../../out-paths'
 
 interface RecordFile {
   version: number
@@ -45,7 +46,7 @@ export function installRouteFactsCache(config: ResolvedConfig) {
   // eslint-disable-next-line turbo/no-undeclared-env-vars
   if (process.env.PNEXT_DEV_FACTS_CACHE === '0') return
   const cache: FactsCache = {
-    dir: path.join(config.outPath, 'cache', 'route-facts'),
+    dir: path.join(outCachePath(config.outPath), 'route-facts'),
     key: lazyRecordCacheKey(config, RECORD_VERSION),
     written: new Set(),
   }

package/src/dev/server.ts

@@ -52,7 +52,7 @@ import {
   staticMetadataCacheControl,
 } from '../routing/metadata-files'
 import { handleRouteModule, type RouteHandlerModule } from '../routing/handler'
-import { malformedUrlResponse, trailingSlashRedirect } from '../routing/href'
+import { malformedUrlResponse, repeatedSlashRedirect, trailingSlashRedirect } from '../routing/href'
 import { type PeerAddressSource, withForwardedHeaders } from '../routing/forwarded'
 import {
   assertNoServerActionsWithoutCompat,
@@ -87,7 +87,14 @@ import {
   setWorkUnitRoute,
 } from '../request/context'
 import { setRequestRuntime } from '../routing/request-environment'
-import { ensureDir, listFiles, writeText } from '../utils/fs'
+import {
+  ensureDir,
+  exactNameIndex,
+  type ExactNames,
+  hasExactName,
+  listFiles,
+  writeText,
+} from '../utils/fs'
 import { contentType } from '../utils/content-type'
 import { traceEnabled } from '../utils/trace-flags'
 import {
@@ -114,6 +121,7 @@ import { cacheRoot, setDevWatcherFreshness } from '../runtime/module-cache'
 import { abortUpstreamFetchOnDisconnect } from '../runtime/fetch-host'
 import { markBoot } from '../cli/boot/trace'
 import { formatDuration } from '../utils/verbose'
+import { outCachePath } from '../out-paths'
 
 interface DevServerOptions {
   config: ResolvedConfig
@@ -210,7 +218,7 @@ async function evictStaleClientCaches(outPath: string) {
   // eslint-disable-next-line turbo/no-undeclared-env-vars
   const keep = Number(process.env.PNEXT_DEV_CLIENT_CACHE_KEEP || 32)
   if (!Number.isFinite(keep) || keep <= 0) return
-  const clientRoot = path.join(outPath, 'cache', 'client')
+  const clientRoot = path.join(outCachePath(outPath), 'client')
   try {
     const entries = await readdir(clientRoot)
     if (entries.length <= keep) return
@@ -290,6 +298,7 @@ export async function startDevServer(options: DevServerOptions) {
   markBoot('boot:scanRoutes')
   await validateProxyFiles(config)
   let proxyRunner = createProxyRunner(config)
+  const exactNames = exactNameIndex(config.root)
   markBoot('boot:proxy')
   let devImportVersion = String(Date.now())
   // The proxy runs serially in front of every request, so its compile+import is
@@ -436,6 +445,8 @@ export async function startDevServer(options: DevServerOptions) {
     if (badRequest) return badRequest
     request = withForwardedHeaders(request, server)
     let url = new URL(request.url)
+    const slashRedirect = repeatedSlashRedirect(url)
+    if (slashRedirect) return slashRedirect
     const profile = devRequestProfile(request, url)
     if (profile) logDevProfile(profile, 'prologue (bootstrap/headers/url)', prologueStart)
     let pageLog = startDevPageStallTimer(pendingDevPageLoadLog(routes, request, url))
@@ -475,6 +486,10 @@ export async function startDevServer(options: DevServerOptions) {
     }
 
     try {
+      // Before the proxy, for every method, as in Next: the proxy only ever sees canonical paths.
+      const canonicalRedirect = trailingSlashRedirect(config, url)
+      if (canonicalRedirect) return finish(canonicalRedirect)
+
       const initialPrefetchResponse = maybeDevPagePrefetchResponse(routes, url.pathname, request)
       if (initialPrefetchResponse) return finish(initialPrefetchResponse)
 
@@ -570,7 +585,7 @@ export async function startDevServer(options: DevServerOptions) {
       }
 
       const staticResponse = await profileDevStep(profile, 'static lookup', () =>
-        maybeStaticFile(config.publicPath, url.pathname),
+        maybeStaticFile(config.publicPath, url.pathname, exactNames),
       )
       if (staticResponse) {
         setWorkUnitRoute('static-asset', 'static')
@@ -582,7 +597,11 @@ export async function startDevServer(options: DevServerOptions) {
           .staticAssetPublicPrefixes()
           .some(prefix => url.pathname.startsWith(prefix))
       ) {
-        const emitted = await maybeStaticFile(path.join(config.outPath, 'public'), url.pathname)
+        const emitted = await maybeStaticFile(
+          path.join(config.outPath, 'static'),
+          url.pathname,
+          exactNames,
+        )
         if (emitted) {
           setWorkUnitRoute('static-asset', 'static')
           return finish(applyProxyResponse(emitted, proxyResponse))
@@ -595,8 +614,9 @@ export async function startDevServer(options: DevServerOptions) {
       )
       if (staticAssetPathname) {
         const outPublicStatic = await maybeStaticFile(
-          path.join(config.outPath, 'public'),
+          path.join(config.outPath, 'static'),
           staticAssetPathname,
+          exactNames,
         )
         if (outPublicStatic) {
           setWorkUnitRoute('static-asset', 'static')
@@ -647,9 +667,6 @@ export async function startDevServer(options: DevServerOptions) {
         }
       }
 
-      const canonicalRedirect = trailingSlashRedirect(config, url, request.method.toUpperCase())
-      if (canonicalRedirect) return finish(applyProxyResponse(canonicalRedirect, proxyResponse))
-
       const nav = parseNavState(request)
       const matched = profileDevSyncStep(profile, 'match route', () =>
         selectRouteForRequest(routes, url.pathname, nav),
@@ -1258,7 +1275,7 @@ async function buildDevClient(config: ResolvedConfig, route: RouteManifestEntry)
     batchRoutes.length === 1
       ? cacheKeys[0]!
       : `batch-${clientSourceHash([...cacheKeys].sort().join('\n'))}`
-  const outDir = path.join(config.outPath, 'cache', 'client', cacheKey)
+  const outDir = path.join(outCachePath(config.outPath), 'client', cacheKey)
   const outFile = path.join(outDir, `${clientEntryName(route)}.js`)
 
   // Dedup in-flight builds first. A single page view fires up to three requests
@@ -1345,7 +1362,7 @@ async function resolveDevClientChunk(config: ResolvedConfig, name: string) {
   const settled = clientChunks.get(name)
   if (settled && existsSync(settled)) return settled
 
-  const clientRoot = path.join(config.outPath, 'cache', 'client')
+  const clientRoot = path.join(outCachePath(config.outPath), 'client')
   for (const generation of await readdir(clientRoot).catch(() => [])) {
     const chunksDir = path.join(clientRoot, generation, 'chunks')
     const file = path.join(chunksDir, name)
@@ -1402,9 +1419,12 @@ async function maybeStaticMetadataFile(config: ResolvedConfig, url: URL) {
   })
 }
 
-async function maybeStaticFile(publicPath: string, pathname: string) {
+async function maybeStaticFile(publicPath: string, pathname: string, exactNames: ExactNames) {
   const filePath = path.join(publicPath, pathname.replace(/^\/+/, ''))
   if (!isInside(publicPath, filePath) || !existsSync(filePath)) return null
+  if (exactNames && !hasExactName(exactNames, publicPath, path.relative(publicPath, filePath))) {
+    return null
+  }
   const fileStat = await stat(filePath)
   if (!fileStat.isFile()) return null
   return devResponse(await readFile(filePath), contentType(filePath))
@@ -1481,8 +1501,8 @@ async function maybeBuiltAsset(
   }
 
   const outPath = config.outPath
-  const filePath = path.join(outPath, 'cache', pathname.replace(/^\/+/, ''))
-  if (!isInside(path.join(outPath, 'cache'), filePath) || !existsSync(filePath)) return null
+  const filePath = path.join(outCachePath(outPath), pathname.replace(/^\/+/, ''))
+  if (!isInside(path.join(outCachePath(outPath)), filePath) || !existsSync(filePath)) return null
   const fileStat = await stat(filePath)
   if (!fileStat.isFile()) return null
   return new Response(await readFile(filePath), {

package/src/extensions.ts

@@ -80,6 +80,9 @@ export function createExtensionHost(): ExtensionHost {
 }
 
 let activeHost = createExtensionHost()
+// Anchored for modules that must not import this one (api/server, shared by embedded hosts).
+const ANCHOR = Symbol.for('pnext.extensionHost')
+;(globalThis as Record<symbol, unknown>)[ANCHOR] ??= activeHost
 
 /** The host every accessor in this module reads. */
 export function getExtensionHost(): ExtensionHost {
@@ -148,6 +151,7 @@ export function withExtensionHost<T>(host: ExtensionHost, callback: () => T): T
 }
 
 function announceHostChange() {
+  ;(globalThis as Record<symbol, unknown>)[ANCHOR] = activeHost
   for (const handler of resetHandlers) handler()
   // Consumers latch the loadable-extension set (the server load plugin's filter
   // regex); a swap changes it, so invalidate exactly as a registration would.

package/src/out-paths.ts

@@ -0,0 +1,10 @@
+import path from 'node:path'
+
+/** The release a build writes under the out root: everything a production server reads. */
+export const standaloneOutSegment = 'standalone'
+
+/** The build cache beside a release (`<outRoot>/cache`); dev keeps its own. */
+export function outCachePath(outPath: string) {
+  const owner = path.basename(outPath) === standaloneOutSegment ? path.dirname(outPath) : outPath
+  return path.join(owner, 'cache')
+}

package/src/render/hooks.ts

@@ -66,12 +66,25 @@ export interface FontExtensions {
    * the same memo the render reads. Default: none.
    */
   prewarmFontAssets: (config: ResolvedConfig, options: { dev?: boolean }) => Promise<void>
+
+  /** Resolve every declared font for a release, keyed like the render looks them up. Default: none. */
+  releaseFonts: (config: ResolvedConfig) => Promise<Record<string, ReleasedFont>>
+}
+
+/** A font resolution as a release stores it; production serves it instead of resolving. */
+export interface ReleasedFont {
+  css: string
+  sizeAdjust: boolean
+  preloads: import('../types').MetadataLink[]
+  usesFonts: boolean
+  files: string[]
 }
 
 const fontExtensions: FontExtensions = {
   runWithFontScope: callback => callback(),
   collectFontAssets: () => Promise.resolve({ css: '', preloads: [] }),
   prewarmFontAssets: () => Promise.resolve(),
+  releaseFonts: () => Promise.resolve({}),
 }
 
 export function getFontExtensions(): FontExtensions {

package/src/render/renderer.ts

@@ -3,7 +3,6 @@ import { stat, unlink, writeFile } from 'node:fs/promises'
 import { basename, dirname, join, relative, sep } from 'node:path'
 import { createHash } from 'node:crypto'
 import { AsyncLocalStorage } from 'node:async_hooks'
-import { drainPreplanBuilds } from '../runtime/vendor'
 import {
   Component,
   Fragment,
@@ -29,10 +28,13 @@ import { markErrorLogged } from '../utils/error-log'
 import {
   devClientModuleHref,
   devServerModuleHref,
+  drainPreplanBuilds,
   importDevModule,
   importModuleOnce,
-} from '../runtime/modules'
-import { serverBundleTargetForRuntime } from '../runtime/loader'
+  registerServerRuntime,
+  serverBundleTargetForRuntime,
+} from '../runtime/load'
+import { conventionFileExists, productionRelease, servedConventions } from '../runtime/production'
 import {
   getActionModuleExtensions,
   getActiveMetadataExtensions,
@@ -63,7 +65,7 @@ import {
   routeCssAssetNames,
   routeCssHref,
   withAssetPrefix,
-} from '../css/build'
+} from '../css/assets'
 import { dynamicReferenceSymbol, type DynamicReference } from '../api/dynamic'
 import {
   isForbiddenError,
@@ -98,13 +100,11 @@ import {
   trackPrerenderDynamic,
 } from './ppr'
 import {
-  collectFileCss,
-  collectNotFoundCss,
   findConventionFiles,
   findGlobalError,
   findLayouts,
   serverActionsUnsupportedMessage,
-} from '../routing/routes'
+} from '../routing/match'
 import { matchSegments, pathnameSegments, slotDirectoriesIn } from '../routing/slots'
 import { getRequestRuntime } from '../routing/request-environment'
 import { toNextRequest } from '../api/server'
@@ -121,7 +121,6 @@ import {
   ISLAND_BOUNDARY_ERROR_MESSAGE_ATTRIBUTE,
 } from './boundary-error'
 import { captureCacheScope, runWithCacheScope } from '../request/cache'
-import { registerServerRuntime } from '../runtime/loader'
 import { readText } from '../utils/fs'
 import { traceEnabled } from '../utils/trace-flags'
 import {
@@ -804,7 +803,7 @@ function moduleHref(file: string, options: ModuleLoadOptions) {
     ? devServerModuleHref(options.config, file, options.devImportVersion ?? String(Date.now()), {
         conditionTarget,
       })
-    : reactCompatEnabled(options.config)
+    : reactCompatEnabled(options.config) || productionRelease(options.config)
       ? devServerModuleHref(options.config, file, 'build', { conditionTarget })
       : pathToFileHref(file)
 }
@@ -851,6 +850,17 @@ async function importClientModule(file: string, options: ModuleLoadOptions) {
   return importModuleOnce<Record<string, unknown>>(href)
 }
 
+/** A synthetic route's CSS: in a release, the stylesheet its build emitted; else a source scan. */
+async function syntheticRouteCss(
+  config: ResolvedConfig,
+  id: string,
+  scan: (routes: typeof import('../routing/routes')) => Promise<string[]>,
+) {
+  if (!productionRelease(config)) return scan(await import('../routing/routes'))
+  const name = `${id}.css`
+  return emittedAssetName(config, name) === name ? [] : [name]
+}
+
 function clientScriptPath(route: RouteManifestEntry, dev?: boolean) {
   return dev
     ? `/__pnext/client/${route.id}.js`
@@ -1530,7 +1540,7 @@ async function serializablePageProps(props: PageProps, omitSearchParams = false)
 
 export async function staticParamsFor(config: ResolvedConfig, route: RouteManifestEntry) {
   const moduleFiles = [
-    ...findLayouts(config.appPath, route.file).filter(file => existsSync(file)),
+    ...findLayouts(config.appPath, route.file).filter(conventionFileExists),
     route.file,
   ]
   let paramSets: Record<string, RouteParamValue>[] = [{}]
@@ -1615,7 +1625,7 @@ export async function renderPage(options: RenderOptions) {
 export async function renderPageWithStatus(
   options: RenderOptions,
 ): Promise<{ html: string; status: number; location?: string }> {
-  registerServerRuntime(options.config, options.route.sourceFiles)
+  await registerServerRuntime(options.config, options.route.sourceFiles)
   await seedPrerenderSidecar(options)
   const request = renderScopeRequest(options)
   return runWithRequest(
@@ -1648,7 +1658,7 @@ export async function renderPageWithStatus(
 }
 
 export async function renderPageStream(options: RenderOptions) {
-  registerServerRuntime(options.config, options.route.sourceFiles)
+  await registerServerRuntime(options.config, options.route.sourceFiles)
   await seedPrerenderSidecar(options)
 
   const request = renderScopeRequest(options)
@@ -1666,7 +1676,7 @@ export async function renderPageStream(options: RenderOptions) {
 }
 
 export async function renderPageResponse(options: RenderOptions) {
-  registerServerRuntime(options.config, options.route.sourceFiles)
+  await registerServerRuntime(options.config, options.route.sourceFiles)
   const method = options.request?.method.toUpperCase() ?? 'GET'
   if (method !== 'GET' && method !== 'HEAD') {
     return new Response('Method Not Allowed', {
@@ -1871,7 +1881,7 @@ const rejectedPprShellUpgrades = new Set<string>()
  * when dynamic data escapes every boundary - the route must then be served fully dynamically.
  */
 export async function renderPartialShell(options: RenderOptions): Promise<PrebuiltShell | null> {
-  registerServerRuntime(options.config, options.route.sourceFiles)
+  await registerServerRuntime(options.config, options.route.sourceFiles)
   const sidecar = getRenderExtensions().prerenderSidecar
   const sidecarContext = prerenderSidecarContext(options)
   await sidecar.begin(sidecarContext)
@@ -1960,7 +1970,7 @@ export async function renderPartialShell(options: RenderOptions): Promise<Prebui
 export async function renderRuntimePrefetchDocument(
   options: RenderOptions,
 ): Promise<{ html: string; postponed: boolean } | null> {
-  registerServerRuntime(options.config, options.route.sourceFiles)
+  await registerServerRuntime(options.config, options.route.sourceFiles)
   // Seed (read-only) the resume-data sidecar so 'use cache' scopes resolve
   // their build-time fills; unlike renderPartialShell nothing is collected or
   // persisted back.
@@ -2512,7 +2522,7 @@ function hasParamFreeRootLayout(config: ResolvedConfig): boolean {
   const cached = paramFreeRootLayoutCache.get(config.appPath)
   if (cached !== undefined) return cached
   const found = ['tsx', 'jsx', 'ts', 'js'].some(ext =>
-    existsSync(join(config.appPath, `layout.${ext}`)),
+    conventionFileExists(join(config.appPath, `layout.${ext}`)),
   )
   paramFreeRootLayoutCache.set(config.appPath, found)
   return found
@@ -2636,7 +2646,7 @@ export async function renderGlobalNotFoundResponse(
 ) {
   const globalFile = ['tsx', 'ts', 'jsx', 'js']
     .map(ext => `${options.config.appPath}/global-not-found.${ext}`)
-    .find(candidate => existsSync(candidate))
+    .find(conventionFileExists)
   // Render as GET regardless of the original method: the 404 page is what a
   // browser should see for a stray POST too (Next's MPA fallback), not a 405.
   const notFoundRequest = options.request
@@ -2664,9 +2674,9 @@ export async function renderGlobalNotFoundResponse(
       // Include CSS shared with the root layout: this document replaces the
       // whole page (no root layout render), so the global sheet isn't linked
       // and anything it covered must ship in this route's own chunk.
-      cssImports: await collectFileCss(options.config.appPath, [globalFile], {
-        includeGlobalCss: true,
-      }),
+      cssImports: await syntheticRouteCss(options.config, 'global-not-found', routes =>
+        routes.collectFileCss(options.config.appPath, [globalFile], { includeGlobalCss: true }),
+      ),
       sourceFiles: [globalFile],
       synthetic: true,
     }
@@ -2706,7 +2716,9 @@ export async function renderGlobalNotFoundResponse(
       clientReferences: rootRoute?.clientReferences ?? [],
       // Root not-found ships its own CSS (`/assets/not-found.css`) alongside the
       // root-layout global sheet (`/assets/global.css`, emitted via globalCssHref).
-      cssImports: await collectNotFoundCss(options.config.appPath),
+      cssImports: await syntheticRouteCss(options.config, 'not-found', routes =>
+        routes.collectNotFoundCss(options.config.appPath),
+      ),
       sourceFiles: rootRoute?.sourceFiles ?? [anchor],
       ...(rootRoute?.needsRouterEntry ? { needsRouterEntry: true } : {}),
       // Serve the ROOT route's built client entry: the synthetic id has no
@@ -2863,6 +2875,8 @@ const documentLayoutDefaults = new Map<string, { mtimeMs: number; hasDefault: bo
 async function routeHasDocumentLayout(layoutFiles: string[]) {
   const rootLayout = layoutFiles[0]
   if (!rootLayout) return false
+  const served = servedConventions()
+  if (served) return served.documentLayouts.has(rootLayout)
   let mtimeMs: number
   try {
     mtimeMs = statSync(rootLayout).mtimeMs
@@ -2923,7 +2937,7 @@ async function pageRender(options: RenderOptions, stream: boolean): Promise<Page
       // Drop the non-existent anchor file so we don't try to import it; the
       // layout's `children` is supplied by the `@children` slot instead (see
       // childrenFromSlots).
-      if (pageFile && !existsSync(pageFile)) pageFile = undefined
+      if (pageFile && !conventionFileExists(pageFile)) pageFile = undefined
     }
     const props = profileRenderSyncStep(profile, 'create page props', () =>
       createPageProps(options),
@@ -3254,7 +3268,7 @@ async function renderAuthInterruptPage(
   const fallbackTree = httpAccessFallbackTree(status, message)
   const file = nearestConventionFile(options, `${kind}.tsx`)
   const boundaryOptions = optionsForNotFoundBoundary(options, file)
-  if (!file || !existsSync(file)) {
+  if (!file || !conventionFileExists(file)) {
     return renderTreeOrFallback(
       boundaryOptions,
       fallbackTree,
@@ -3322,7 +3336,7 @@ async function renderGlobalErrorPage(
     // global-error.js is a client component ('use client'): import it through
     // the client module loader and SSR it to a full document. Server components
     // (no directive) load through the server loader.
-    const clientDirective = hasUseClientDirective(await readText(file))
+    const clientDirective = await conventionUsesClient(file)
     const module = (
       clientDirective ? await importClientModule(file, options) : await importModule(file, options)
     ) as ErrorModule
@@ -3389,7 +3403,7 @@ export function withDevReloadScript(html: string, request?: Request): string {
 }
 
 function withGlobalErrorStylesheet(html: string, config: ResolvedConfig): string {
-  const asset = `${config.outPath}/public/assets/${emittedAssetName(config, 'global-error.css')}`
+  const asset = `${config.outPath}/static/assets/${emittedAssetName(config, 'global-error.css')}`
   if (!existsSync(asset)) return html
   const link = `<link rel="stylesheet" href="${assetHref(config, 'global-error.css')}">`
   if (html.includes('</head>')) return html.replace('</head>', `${link}</head>`)
@@ -3956,7 +3970,7 @@ async function renderTreeInFrame(
     // global-not-found replaces the document without the root layout, so the
     // root layout's global sheet must not load (its CSS ships in the route's
     // own chunk, built with includeGlobalCss).
-    options.route.id === 'global-not-found' ? undefined : globalCssHref(options.config)
+    options.route.id === 'global-not-found' ? undefined : await globalCssHref(options.config)
   let routeStylesheet = routeCssHref(options.route, options.config)
   // File names, not logical ones: the inline path READS these off disk, so it has
   // to spell them the way the build emitted them (content-hashed in production).
@@ -4378,7 +4392,7 @@ async function buildLoadingBoundaries(
     options.route.file,
     'loading.tsx',
   )) {
-    if (!existsSync(loadingFile)) continue
+    if (!conventionFileExists(loadingFile)) continue
     const fallback = await buildLoadingFallback(options, loadingFile)
     if (fallback) fallbackByDir.set(dirname(loadingFile), fallback)
   }
@@ -4485,7 +4499,7 @@ async function renderNotFoundPage(
   // A `'use client'` not-found.js with a discovered client reference renders as an island (same as
   // error.js) so it HYDRATES - its hooks must work on the 404 document. Server-rendering it would
   // serialize child event-handler props as dead action stubs.
-  const clientDirective = hasUseClientDirective(await readText(file))
+  const clientDirective = await conventionUsesClient(file)
   const clientReference = clientDirective
     ? conventionDefaultReference(notFoundOptions, file)
     : undefined
@@ -4598,7 +4612,7 @@ async function renderErrorPage(options: RenderOptions, error: unknown, stream: b
   if (!file) return renderGenericErrorPage(options, resolvedError, stream)
 
   try {
-    const clientDirective = hasUseClientDirective(await readText(file))
+    const clientDirective = await conventionUsesClient(file)
     const module = (
       clientDirective ? await importClientModule(file, options) : await importModule(file, options)
     ) as ErrorModule
@@ -4867,10 +4881,16 @@ function generatedFallbackPage(
   }
 }
 
+/** Whether a convention file is `'use client'`: the frozen fact in production, its source otherwise. */
+async function conventionUsesClient(file: string) {
+  const served = servedConventions()
+  return served ? served.client.has(file) : hasUseClientDirective(await readText(file))
+}
+
 function nearestConventionFile(options: RenderOptions, name: string) {
   return [...findConventionFiles(options.config.appPath, options.route.file, name)]
     .reverse()
-    .find(file => existsSync(file))
+    .find(conventionFileExists)
 }
 
 /**
@@ -6541,7 +6561,7 @@ function dynamicTargetReference(
   const target = dynamicReference.target
   if (!target) return undefined
   const stored = state.clientReferences.get(
-    `c-${clientReferenceId(target.file, target.exportName)}`,
+    target.id ?? `c-${clientReferenceId(target.file, target.exportName)}`,
   )
   if (stored) return stored
   for (const reference of state.clientReferences.values()) {
@@ -7616,7 +7636,7 @@ async function applyLayouts(
   await profileRenderStep(profile, 'import layouts', async () => {
     for (const layoutPath of options.layoutFiles ??
       findLayouts(options.config.appPath, options.route.file)) {
-      if (!options.moduleLoader && !existsSync(layoutPath)) continue
+      if (!options.moduleLoader && !conventionFileExists(layoutPath)) continue
       const layoutModule = (await importModule(layoutPath, options)) as LayoutModule
       markServerReference(layoutModule.default)
       // Cheap leaf span for the segment-module resolution (nested under the
@@ -8025,7 +8045,7 @@ function fullSegmentPrefetchSkipsSharedLayout(options: RenderOptions): boolean {
     options.config.appPath,
     options.route.file,
     'layout.tsx',
-  ).filter(file => existsSync(file))
+  ).filter(conventionFileExists)
   const documentDir = layoutFiles[0] ? dirname(layoutFiles[0]) : undefined
   return layoutFiles
     .slice(1)

package/src/request/context.ts

@@ -8,6 +8,7 @@ import {
   PostponeError,
 } from '../render/ppr'
 import type { NextRequest, RouteParamValue } from '../types'
+import type { Release } from '../runtime/production'
 
 // Request work-unit store (CORE seam for compat after()/onRequestError).
 //
@@ -46,6 +47,8 @@ export interface WorkUnit {
    * grows no dependency on compat.
    */
   compat?: Record<symbol, unknown>
+  /** The production release this request serves from; dev and build leave it unset. */
+  release?: Release
 }
 
 // Anchored on globalThis (like requestStorage below) so compiled compat
@@ -67,6 +70,12 @@ export function getWorkUnit(): WorkUnit | undefined {
   return workUnitStorage.getStore()
 }
 
+/** Mark the current work unit as serving `release` (production reads its app facts from it). */
+export function setWorkUnitRelease(release: Release): void {
+  const unit = workUnitStorage.getStore()
+  if (unit) unit.release = release
+}
+
 /** Set the current work-unit phase (compat toggles render/action/handler/...). */
 export function setPhase(phase: WorkUnitPhase): void {
   const unit = workUnitStorage.getStore()

package/src/resolve/dynamic.ts

@@ -1,3 +1,4 @@
+import { clientReferenceId } from '../client/reference'
 import { dynamicCallFacts, rewriteFacts, type DynamicCallFact } from './scan-facts'
 
 export interface DynamicCall {
@@ -132,7 +133,8 @@ export function rewriteDynamicCallTargets(
     const args = source.slice(call.open + 1, call.close)
     const argCount = topLevelArgCount(args)
     if (argCount < 1 || argCount > 2) continue
-    const literal = JSON.stringify({ file, exportName: target.exportName })
+    const id = `c-${clientReferenceId(file, target.exportName)}`
+    const literal = JSON.stringify({ file, exportName: target.exportName, id })
     const separator = /,\s*$/.test(args) ? '' : ', '
     edits.push({
       at: call.close,
@@ -222,6 +224,7 @@ export function deferredDynamicImportSpecifiers(source: string, file?: string) {
   }
 
   const facts = dynamicCallFacts(source, file)
+  const rendered = new Set<string>()
   for (const call of dynamicCallsFromSource(source, dynamicNames)) {
     const target = loaderImportTargetForCall(call, facts)
     if (!target) continue
@@ -237,7 +240,10 @@ export function deferredDynamicImportSpecifiers(source: string, file?: string) {
     const visible =
       /\bload\s*:\s*['"]visible['"]/.test(options) && !/\bssr\s*:\s*true\b/.test(options)
     if (ssrFalse || visible) deferred.add(target.specifier)
+    else rendered.add(target.specifier)
   }
+  // A target another call server-renders must compile for the server.
+  for (const specifier of rendered) deferred.delete(specifier)
   return deferred
 }
 

package/src/resolve/engine.ts

@@ -2,6 +2,7 @@ import { existsSync } from 'node:fs'
 import path from 'node:path'
 import type { ResolverFactory, NapiResolveOptions } from 'oxc-resolver'
 import { loadNative } from '../utils/native-require'
+import { splitResourceQuery } from '../utils/resource-query'
 
 // Lazy: the native binding costs ~1.3 MB RSS and a prod server may never resolve.
 function createResolverFactory(options: NapiResolveOptions): ResolverFactory {
@@ -95,18 +96,7 @@ export function tsConfigFileFor(root: string): string | undefined {
   return file
 }
 
-/**
- * Split a webpack resource specifier into its file request and its `?query#fragment` suffix - loader
- * plumbing (turbopack rules, `.wasm?module`) that takes no part in the on-disk lookup. A leading `#` is a
- * package-imports specifier, not a fragment.
- */
-export function splitResourceQuery(specifier: string): { path: string; query: string } {
-  const offset = specifier.startsWith('#') ? 1 : 0
-  const match = /[?#]/.exec(specifier.slice(offset))
-  if (!match) return { path: specifier, query: '' }
-  const index = offset + match.index
-  return { path: specifier.slice(0, index), query: specifier.slice(index) }
-}
+export { splitResourceQuery }
 
 /**
  * Resolve `specifier` from `dir`. `tsConfigRoot` opts the lookup into that