@wular/pnext 0.1.6 → 0.1.8

package/src/cli/analyze.ts

@@ -8,6 +8,7 @@ import { matchRoute } from '../routing/routes'
 import { bold, cyan, dim } from '../utils/ansi'
 import { listFiles } from '../utils/fs'
 import type { BuildManifest, RouteManifestEntry } from '../types'
+import { buildManifestFile } from '../runtime/production'
 
 export interface AnalyzeResult {
   root: string
@@ -109,7 +110,7 @@ async function analyzeRouteBundles(
   files: AnalyzeFile[],
   routeFilter?: string,
 ) {
-  const manifestPath = path.join(outPath, 'manifest.json')
+  const manifestPath = buildManifestFile(outPath)
   if (!existsSync(manifestPath)) return []
 
   const manifest = JSON.parse(await readFile(manifestPath, 'utf8')) as BuildManifest
@@ -374,7 +375,7 @@ function prerenderedPathname(route: RouteManifestEntry) {
 function analyzeTarget(outPath: string) {
   // PPR shells live in `.pnext/ppr`, outside `public`: they are resumed
   // server-side and never downloaded, so they are not shipped weight.
-  const publicPath = path.join(outPath, 'public')
+  const publicPath = path.join(outPath, 'static')
   return existsSync(publicPath) ? { root: publicPath } : null
 }
 

package/src/cli/build/cache.ts

@@ -7,9 +7,11 @@ import type { ResolvedConfig } from '../../config'
 import { frameworkFingerprint } from '../../runtime/fingerprint'
 import type { BuildManifest } from '../../types'
 import { writeFileAtomic } from '../../utils/fs'
+import { buildManifestFile } from '../../runtime/production'
+import { outCachePath } from '../../out-paths'
 
 const CACHE_VERSION = 2
-const CACHE_SEGMENTS = ['cache', 'build'] as const
+const CACHE_SEGMENTS = ['build'] as const
 const SKIP_INPUT_DIRS = new Set([
   '.claude',
   '.git',
@@ -75,9 +77,7 @@ export async function lookupBuildCache(
   }
   try {
     const manifest = resolveManifest(
-      JSON.parse(
-        await readFile(path.join(config.outPath, 'manifest.json'), 'utf8'),
-      ) as BuildManifest,
+      JSON.parse(await readFile(buildManifestFile(config.outPath), 'utf8')) as BuildManifest,
       config.outPath,
       config.root,
     )
@@ -121,7 +121,7 @@ function cacheEnabled(options: BuildCacheOptions) {
 }
 
 function cacheDir(outPath: string) {
-  return path.join(outPath, ...CACHE_SEGMENTS)
+  return path.join(outCachePath(outPath), ...CACHE_SEGMENTS)
 }
 
 function recordFile(outPath: string) {
@@ -220,7 +220,7 @@ async function collectModuleGraphInputs(config: ResolvedConfig, files: Map<strin
   let parsed: ModuleGraphIndex
   try {
     parsed = JSON.parse(
-      await readFile(path.join(config.outPath, 'cache', 'server', 'graph.json'), 'utf8'),
+      await readFile(path.join(outCachePath(config.outPath), 'server', 'graph.json'), 'utf8'),
     ) as ModuleGraphIndex
   } catch {
     return

package/src/cli/build.ts

@@ -25,13 +25,15 @@ import { beginSourceScope, endSourceScope, sourceCacheStats } from '../resolve/s
 import { flushDevModuleCaches } from '../runtime/module-cache'
 import { scanFactsStats } from '../resolve/scan-facts'
 import { clientEntryName } from '../client/chunk-name'
+import { compiledClientReferenceFiles } from '../client/reference'
+import { buildIndexFile, buildManifestFile } from '../runtime/production'
 import { registerServerRuntime, serverBundleTargetForRuntime } from '../runtime/loader'
 import {
-  buildClientReferenceCss,
   buildGlobalCss,
   buildNotFoundCss,
-  buildRouteCss,
+  buildRouteStylesheets,
   emittedAssetNames,
+  globalCssSources,
   prepareRouteCssChunks,
   registerCssRuntime,
   warmCssPipeline,
@@ -72,6 +74,7 @@ import {
   devServerModuleHref,
   resetModuleGraphFailure,
   setEmitCompiledSpecifiersManifest,
+  setReleaseCompile,
   throwIfModuleGraphFailed,
 } from '../runtime/modules'
 import {
@@ -91,7 +94,8 @@ import {
 import { interceptionMarkerLevels } from '../routing/slots'
 import { writeTypegen } from './typegen'
 import { lookupBuildCache, writeBuildCache } from './build/cache'
-import { emitServerEntry } from './serve/entry'
+import { startStandalone, writeStandalone } from './serve/standalone'
+import { immutableAssetPath } from './serve/immutable'
 import { createVerboseLogger, type VerboseLogger } from '../utils/verbose'
 import { bold, cyan, dim, green } from '../utils/ansi'
 import type {
@@ -165,6 +169,7 @@ export async function buildProject(root?: string, options: BuildOptions = {}) {
   // Only the vercel adapter's trace step reads the per-artifact specifier
   // sidecars; every other build path pays nothing for them.
   const restoreSpecifiersManifest = setEmitCompiledSpecifiersManifest(options.adapter === 'vercel')
+  const restoreReleaseCompile = setReleaseCompile(true)
   const lifecycle: { warm?: WarmChild } = {}
   try {
     return await runBuild(root, options, lifecycle)
@@ -177,6 +182,7 @@ export async function buildProject(root?: string, options: BuildOptions = {}) {
     lifecycle.warm?.kill()
     endSourceScope()
     restoreSpecifiersManifest()
+    restoreReleaseCompile()
     flushDevModuleCaches()
   }
 }
@@ -225,11 +231,14 @@ async function runBuild(
   const warmMode = options.adapter === 'vercel' ? 'full' : 'compile'
   const warm = startWarmChild(config, warmMode)
   lifecycle.warm = warm
-  await log.step('prepare output directory', async () => {
+  // The framework's half of the standalone trace needs no build output; it overlaps the bundling.
+  const standalone = startStandalone(config)
+  const publicFiles = await log.step('prepare output directory', async () => {
     // Build-owned outputs only: `<outRoot>/dev` belongs to a possibly-running
     // dev server and must survive.
-    await ensureEmptyDir(config.outPath, [devOutSegment])
-    await copyPublicDir(config.publicPath, path.join(config.outPath, 'public'))
+    // Materialized pages sources too: this build's config already resolved into them.
+    await ensureEmptyDir(config.outRootPath, [devOutSegment, 'pnext-pages-compat'])
+    return copyPublicDir(config.publicPath, path.join(config.outPath, 'static'))
   })
   // The document-level stylesheets run their postcss/Tailwind pass on the CSS
   // worker, so they overlap with the route scan below instead of serializing
@@ -305,6 +314,14 @@ async function runBuild(
   // - those are awaited just before the first route stylesheet is emitted, which lets a Tailwind
   // pass run under the build steps and the client bundles instead of ahead of them.
   prepareRouteCssChunks(routes)
+  // Route stylesheets bundle all at once under the client stage; the loop below publishes each
+  // route's names right before its prerender, after the document ones.
+  const routeStylesheets = buildRouteStylesheets(
+    config,
+    routes.filter(route => route.kind !== 'handler' && !route.dynamicErrorApi),
+    documentCss,
+    { verbose },
+  )
   // output:'export' with trailingSlash:false lays prerendered pages out flat
   // (`/a.html` rather than `/a/index.html`). Only meaningful under compat (the
   // Next config carries `output`); pure-core apps always use the dir layout.
@@ -353,9 +370,11 @@ async function runBuild(
       )
     : undefined
   metadataWarnings?.catch(() => undefined)
-  const staticModuleMetadata = await log.step('core module metadata', () =>
+  // Imports the route modules; the client stage needs none of it, so both run at once.
+  const moduleMetadata = log.step('core module metadata', () =>
     collectStaticModuleMetadata(config, routes),
   )
+  moduleMetadata.catch(() => undefined)
 
   const actionSources = buildState.actionSources ?? buildState.actions.map(a => a.sourceKey)
   // realpath, not resolve: a hybrid app's routes are scanned through the pages-compat mirror, whose
@@ -366,13 +385,18 @@ async function runBuild(
   // A node_modules action module never lands in route.sourceFiles itself (that walk stops at the
   // package boundary), so a route reaching one only through a first-party importer is matched here.
   const actionImporters = new Set((buildState.actionImporters ?? []).map(realFilePath))
+  // Routes share most of their files; resolve each once.
+  const realFiles = new Map<string, string>()
+  const reachesAction = (file: string) => {
+    let real = realFiles.get(file)
+    if (real === undefined) realFiles.set(file, (real = realFilePath(file)))
+    return actionFiles.has(real) || actionImporters.has(real)
+  }
   for (const route of routes) {
     if (
       route.kind === 'page' &&
-      route.sourceFiles.some(file => {
-        const real = realFilePath(file)
-        return actionFiles.has(real) || actionImporters.has(real)
-      })
+      (actionFiles.size > 0 || actionImporters.size > 0) &&
+      route.sourceFiles.some(reachesAction)
     ) {
       addClientEntryReason(route, 'actions')
     }
@@ -389,7 +413,7 @@ async function runBuild(
       buildClientEntries({
         config,
         routes: clientRoutes,
-        outDir: path.join(config.outPath, 'public', 'assets'),
+        outDir: path.join(config.outPath, 'static', 'assets'),
         verbose,
         hasServerActions: actionSources.length > 0,
         pipeline: clientSources,
@@ -400,14 +424,14 @@ async function runBuild(
   // other document does, and those names are only final once the client stage has
   // fingerprinted them — so this render follows the bundle rather than racing it.
   // Result is consumed after the prerender pass, where it always was.
-  const notFoundDocuments = clientBundles.then(() =>
+  const notFoundDocuments = clientBundles.then(async () =>
     renderNotFoundDocuments({
       config,
       log,
       skip: options.buildMode === 'compile',
       documentCss,
       staticMetadataFiles,
-      staticModuleMetadata,
+      staticModuleMetadata: await moduleMetadata,
     }),
   )
   notFoundDocuments.catch(() => undefined)
@@ -420,13 +444,14 @@ async function runBuild(
   ).then(() => log.step('typegen', () => writeTypegen(config, routes)))
   remainingSteps.catch(() => undefined)
   await remainingSteps
+  const staticModuleMetadata = await moduleMetadata
   await clientBundles
   const proxyModule = await proxyBuild
   await partytownLib
   // Standalone static chunks (compat: the no-module polyfills chunk) live
   // outside the esbuild entry graph, so emit them regardless of whether any
   // route produced a client bundle.
-  await emitStaticClientChunks(config, path.join(config.outPath, 'public', 'assets'))
+  await emitStaticClientChunks(config, path.join(config.outPath, 'static', 'assets'))
   // All three source consumers have run by here; the split says how much of the
   // app was read once and shared rather than read per consumer.
   if (verbose) {
@@ -472,8 +497,7 @@ async function runBuild(
   const generateFailures: { route: string; omitErrorLine: boolean }[] = []
   if (isGenerate) console.log('   Collecting page data ...')
 
-  // Route stylesheets build strictly after the document ones; this is the first
-  // point that needs them, so everything above ran alongside the CSS worker.
+  // The first point that needs the stylesheets, so everything above ran alongside them.
   await documentCss
 
   for (const route of routes) {
@@ -515,10 +539,7 @@ async function runBuild(
       continue
     }
 
-    await buildRouteCss(config, route, { verbose })
-    for (const reference of route.clientReferences) {
-      await buildClientReferenceCss(config, reference, { verbose })
-    }
+    await routeStylesheets.get(route)?.()
 
     // Compile mode bundles only — every prerender/export step is generate's.
     if (isCompile) continue
@@ -768,7 +789,7 @@ async function runBuild(
               html: rendered.value.html,
               status: rendered.value.status,
             })
-            const relative = toPosixPath(path.relative(path.join(config.outPath, 'public'), file))
+            const relative = toPosixPath(path.relative(path.join(config.outPath, 'static'), file))
             const revalidateSeconds = combineRevalidate(
               segmentConfig?.revalidate,
               rendered.revalidateSeconds,
@@ -906,6 +927,7 @@ async function runBuild(
   // carries its entries, so this is where it has to have landed.
   await deferredSteps
   const actions = buildState.actions
+  const publicAssets = publicFiles.filter(relative => immutableAssetPath(relative))
   const manifest: BuildManifest = {
     version: 0,
     root: config.root,
@@ -916,6 +938,7 @@ async function runBuild(
     // The serving process re-publishes these so a render resolves the same
     // content-hashed names the build emitted.
     assetNames: emittedAssetNames(config.outPath),
+    ...(publicAssets.length > 0 ? { publicAssets } : {}),
     staticMetadataFiles,
     ...(Object.keys(staticModuleMetadata).length > 0 ? { staticModuleMetadata } : {}),
     ...(!config.compat?.next
@@ -930,18 +953,25 @@ async function runBuild(
   }
   await writeBuildManifest(config.outPath, manifest)
   log.log(`wrote manifest.json (${routes.length} route${routes.length === 1 ? '' : 's'})`)
-  await log.step('server entry', () => emitServerEntry(config.outPath))
   for (const hook of getBuildExtensions().completeHooks) {
     await hook({ config, manifest, log })
   }
-  if (options.adapter === 'vercel')
-    await log.step('vercel adapter output', () =>
-      writeVercelOutput(config, manifest, { verbose, warm }),
-    )
-  // Plain build: the adapter owns the child in the branch above. Compiling the
-  // rest of the app's modules is build work, so it counts toward the build's own
+  // Compiling the rest of the app's modules is build work, so it counts toward the build's own
   // duration rather than hiding after it.
-  else await log.step('warm module cache', () => warm.finish(log))
+  await log.step('warm module cache', () =>
+    warm.finish(log, undefined, {
+      globalCss: globalCssSources(config),
+      clientReferences: [...compiledClientReferenceFiles()],
+    }),
+  )
+  // The release names every module production imports; a server compile that did not finish
+  // fails the build here rather than a request later.
+  if (!existsSync(buildIndexFile(config.outPath))) {
+    throw new Error('pnext build: the server compile did not complete (see the error above).')
+  }
+  await log.step('standalone output', () => writeStandalone(config, standalone))
+  if (options.adapter === 'vercel')
+    await log.step('vercel adapter output', () => writeVercelOutput(config, manifest, { verbose }))
 
   // Also cover module loads performed by completion hooks or the warm pass.
   throwIfModuleGraphFailed()
@@ -1046,8 +1076,9 @@ function interceptionDisplayRoute(route: RouteManifestEntry, filled?: string): s
 
 async function writeBuildManifest(outPath: string, manifest: BuildManifest) {
   assertManifestServerArtifacts(outPath, manifest)
-  const file = path.join(outPath, 'manifest.json')
-  const temporary = path.join(outPath, `.manifest-${process.pid}.tmp`)
+  const file = buildManifestFile(outPath)
+  const temporary = `${file}.${process.pid}.tmp`
+  await mkdir(path.dirname(file), { recursive: true })
   await writeFile(temporary, serializeBuildManifest(manifest))
   await rename(temporary, file)
 }
@@ -1057,9 +1088,11 @@ function assertManifestServerArtifacts(outPath: string, manifest: BuildManifest)
     ...(manifest.proxyModule ? [manifest.proxyModule] : []),
     ...(manifest.actions?.map(action => action.modulePath) ?? []),
   ]
+  // Compiled artifacts still sit in the build cache beside the release until writeStandalone moves them.
+  const outRoot = path.dirname(outPath)
   for (const artifact of artifacts) {
     const file = path.resolve(outPath, artifact)
-    if (file !== outPath && !file.startsWith(`${outPath}${path.sep}`)) {
+    if (!file.startsWith(`${outRoot}${path.sep}`)) {
       throw new Error(`Build manifest server artifact escapes output directory: ${artifact}`)
     }
     if (!existsSync(file)) {
@@ -2223,7 +2256,7 @@ async function renderNotFoundDocuments({
 
   if (await shouldBuildGlobalNotFound(config)) {
     await log.step('global not-found', async () =>
-      writeText(path.join(config.outPath, 'public', '404.html'), await render()),
+      writeText(path.join(config.outPath, 'static', '404.html'), await render()),
     )
   }
   // Next always prerenders the built-in `/_not-found` document for a compat
@@ -2231,7 +2264,7 @@ async function renderNotFoundDocuments({
   // `.next/server/app/_not-found.html`). When public/404.html was written, the
   // .next artifacts are copied from it; otherwise they need a document here.
   if (!config.compat?.next) return undefined
-  if (existsSync(path.join(config.outPath, 'public', '404.html'))) return undefined
+  if (existsSync(path.join(config.outPath, 'static', '404.html'))) return undefined
   // Nothing prerenderable to render into the document: either the app authored no not-found.* at
   // all, or it authored one and declared it force-dynamic, in which case Next leaves `/_not-found`
   // dynamic and prerenders no custom 404 either. Emit the standalone default rather than boot the
@@ -2289,7 +2322,7 @@ async function emitNextNotFoundArtifacts(
   fallback404?: string,
 ) {
   if (!config.compat?.next) return
-  const source = path.join(config.outPath, 'public', '404.html')
+  const source = path.join(config.outPath, 'static', '404.html')
   const html = existsSync(source) ? readFileSync(source, 'utf8') : fallback404
   if (html === undefined) return
 
@@ -2506,7 +2539,7 @@ async function buildStaticRouteHandler(
     if (rendered.noStore && !staticRouteHandlerExplicitlyCached(route)) continue
     const body = await settleBeforeNextTask(response.clone().arrayBuffer())
     if (!body) continue
-    const relative = toPosixPath(path.relative(path.join(config.outPath, 'public'), file))
+    const relative = toPosixPath(path.relative(path.join(config.outPath, 'static'), file))
     // Descendant handlers record their manifest entry (so the synthesized
     // prerender-manifest lists them) but skip the on-disk copy that would
     // collide with the ancestor's file; they serve dynamically at runtime.
@@ -2825,7 +2858,7 @@ async function copyStaticMetadataFiles(
 }
 
 export function staticHtmlPath(outPath: string, routePath: string, flatLayout = false) {
-  if (routePath === '/') return path.join(outPath, 'public', 'index.html')
+  if (routePath === '/') return path.join(outPath, 'static', 'index.html')
   const normalized = routePath.replace(/^\/|\/$/g, '')
   // output:'export' with trailingSlash:false lays pages out flat (`/a.html`);
   // otherwise (and always for trailingSlash:true) each page gets its own dir
@@ -2924,7 +2957,7 @@ function staticRouteHandlerPath(outPath: string, routePath: string) {
  * route serves dynamically (start's static lookup only matches real files, then falls through).
  */
 function staticOutputCollision(outPath: string, file: string): string | null {
-  const publicPath = path.join(outPath, 'public')
+  const publicPath = path.join(outPath, 'static')
   if (existsSync(file) && statSync(file).isDirectory()) {
     return `${toPosixPath(path.relative(publicPath, file))} already exists as a directory`
   }
@@ -3144,7 +3177,7 @@ function realFilePath(file: string): string {
 }
 
 function safePublicPath(outPath: string, ...segments: string[]) {
-  const publicPath = path.join(outPath, 'public')
+  const publicPath = path.join(outPath, 'static')
   const file = path.join(publicPath, ...segments)
   const relative = path.relative(publicPath, file)
   if (relative.startsWith('..') || path.isAbsolute(relative)) {
@@ -3171,7 +3204,7 @@ async function copyPartytownLib(config: Awaited<ReturnType<typeof loadConfig>>)
     )
     return
   }
-  const target = path.join(config.outPath, 'public', '_next', 'static', '~partytown')
+  const target = path.join(config.outPath, 'static', '_next', 'static', '~partytown')
   await mkdir(target, { recursive: true })
   await copyPublicDir(libDir, target)
 }
@@ -3194,11 +3227,11 @@ function resolvePartytownLibDir(root: string): string | null {
 }
 
 async function copyPublicDir(from: string, to: string) {
-  const files = await listFiles(from)
-  for (const file of files) {
-    const relative = toPosixPath(path.relative(from, file))
+  const files = (await listFiles(from)).map(file => toPosixPath(path.relative(from, file)))
+  for (const relative of files) {
     const target = path.join(to, relative)
     await mkdir(path.dirname(target), { recursive: true })
-    await copyFile(file, target)
+    await copyFile(path.join(from, relative), target)
   }
+  return files
 }

package/src/cli/index.ts

@@ -50,8 +50,8 @@ markBoot('cli:entry')
 namedBunBinary(commandBinaryName(command))
 
 // Before any command lazily imports esbuild, which captures the binary path on
-// module load.
-nameEsbuildProcess()
+// module load. `start` serves a finished build and never loads it.
+if (command !== 'start') nameEsbuildProcess()
 markBoot('cli:naming')
 
 try {
@@ -90,7 +90,10 @@ try {
   } else if (command === 'start') {
     warnUnknownFlags(command, args)
     const root = positionalRoot(args)
-    const { start } = await import('./start')
+    // A build of other source than this prebundle's is served from that source.
+    const { start } = (await prebundleServes(root))
+      ? await import('./start')
+      : ((await import(new URL('./start.ts', import.meta.url).href)) as typeof import('./start'))
     await start({
       root,
       port: optionNumber(args, '--port'),
@@ -160,6 +163,21 @@ function formatCliError(error: unknown) {
   }
 }
 
+declare const PNEXT_PREBUNDLE: { version: string; fingerprint: string } | undefined
+
+/** Whether this process's prebundle may serve `root`'s build: one made from its source and version. */
+async function prebundleServes(root = process.cwd()) {
+  if (typeof PNEXT_PREBUNDLE !== 'object') return true
+  const [{ DEFAULT_OUT_DIR, standaloneOutSegment }, { buildIndexFile, readBuildIndex }] =
+    await Promise.all([import('../config'), import('../runtime/production')])
+  const outPath = path.resolve(root, DEFAULT_OUT_DIR, standaloneOutSegment)
+  return (
+    !existsSync(buildIndexFile(outPath)) ||
+    (readBuildIndex(outPath).framework === PNEXT_PREBUNDLE.fingerprint &&
+      VERSION === PNEXT_PREBUNDLE.version)
+  )
+}
+
 function positionalRoot(args: string[]) {
   return positionals(args)[0]
 }

package/src/cli/serve/immutable.ts

@@ -0,0 +1,31 @@
+import { getAssetExtensions } from '../../extensions'
+
+export const immutableCacheControl = 'public, max-age=31536000, immutable'
+
+/**
+ * Everything the build emits under `assets/` (served at `/_next/static/*` in
+ * compat) is immutable, which is the promise Next makes for that whole
+ * namespace. It holds because every one of those names carries a content hash:
+ * esbuild's for chunks and fonts, assetContentHash for the route entries and the
+ * stylesheets (see fingerprintClientEntries / fingerprintAsset), and a build id
+ * for `_next/static/<id>/_*Manifest.js`. An UNHASHED name must never reach here —
+ * the same URL would answer different bytes after a deploy, and every browser
+ * that saw the old ones would keep them for a year.
+ *
+ * Route outputs (prerendered html, handler bodies) live outside both prefixes
+ * and stay revalidating; so do the app's own public/ files (manifest.publicAssets).
+ */
+export function immutableAssetPath(relativePath: string) {
+  return immutableAssetPrefixes().some(prefix => relativePath.startsWith(prefix))
+}
+
+/** The public-relative prefixes `immutableAssetPath` covers. */
+export function immutableAssetPrefixes() {
+  return [
+    'assets/',
+    '_next/static/',
+    ...getAssetExtensions()
+      .staticAssetPublicPrefixes()
+      .map(prefix => prefix.replace(/^\/+/, '')),
+  ]
+}