@wular/pnext 0.1.5 → 0.1.7

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

@@ -2,10 +2,11 @@ import { existsSync, realpathSync } from 'node:fs'
 import { fileURLToPath, pathToFileURL } from 'node:url'
 import path from 'node:path'
 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, locateRelease, readBuildIndex, releaseConfig } from './runtime/production'
 
 export type ResolvedConfig = Required<Pick<PNextConfig, 'outDir' | 'basePath'>> &
   Omit<PNextConfig, 'outDir' | 'basePath'> & {
@@ -61,7 +62,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 +80,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 +97,8 @@ export async function loadConfig(
   options: { dev?: boolean; serve?: boolean; warnings?: boolean } = {},
 ): Promise<ResolvedConfig> {
   const root = canonicalRoot(path.resolve(rootInput))
+  const released = options.serve ? locateRelease(root, DEFAULT_OUT_DIR) : 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 +128,13 @@ 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)
+  // 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)
@@ -156,6 +170,36 @@ export async function loadConfig(
   }
 }
 
+/**
+ * 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)
+  const config = releaseConfig(index.config, root, 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],
@@ -264,7 +308,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 +316,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')

package/src/css/assets.ts

@@ -0,0 +1,213 @@
+/**
+ * Built-asset naming and the CSS-module runtime: what a render needs to link stylesheets. The CSS
+ * compiler lives in `./build`; a production server never loads it.
+ */
+import { existsSync } from 'node:fs'
+import { readFile, writeFile } from 'node:fs/promises'
+import path from 'node:path'
+import { getCssExtensions } from '../extensions'
+import { nextCompatEnabled } from '../render/hooks'
+import { productionRelease } from '../runtime/production'
+import { hashedAssetName } from '../utils/asset-hash'
+import { cssModuleScopePath, ensureDir, readText } from '../utils/fs'
+import type { ResolvedConfig } from '../config'
+import type { RouteManifestEntry } from '../types'
+
+let build: Promise<typeof import('./build')> | undefined
+
+export async function globalCssHref(config: ResolvedConfig) {
+  const sources =
+    productionRelease(config)?.globalCss ??
+    (await (build ??= import('./build'))).globalCssSources(config)
+  return sources.length > 0 ? assetHref(config, 'global.css') : undefined
+}
+
+export type AssetHrefConfig = Pick<ResolvedConfig, 'assetPrefix' | 'compat' | 'outPath'>
+
+/**
+ * Logical build-asset name -> the content-hashed name the build actually emitted
+ * (`global.css` -> `global-1f4a9c2b3d5e6f70.css`). A production asset name must
+ * carry its content, or the URL cannot honestly be served `immutable`: the same
+ * name would answer different bytes after a deploy.
+ *
+ * Keyed by outPath, never process-global: one process builds several apps (the
+ * test suite does it constantly) and their names must not cross. Empty in dev,
+ * where names stay flat and every asset is served `no-cache` anyway.
+ */
+const emittedAssets = new Map<string, Map<string, string>>()
+
+export function recordEmittedAsset(outPath: string, logical: string, emitted: string): void {
+  const names = emittedAssets.get(outPath) ?? new Map<string, string>()
+  names.set(logical, emitted)
+  emittedAssets.set(outPath, names)
+}
+
+/** Re-publish the build's name map at server boot (see BuildManifest.assetNames). */
+export function publishEmittedAssets(
+  outPath: string,
+  names: Record<string, string> | undefined,
+): void {
+  if (!names) return
+  for (const [logical, emitted] of Object.entries(names))
+    recordEmittedAsset(outPath, logical, emitted)
+}
+
+export function emittedAssetNames(outPath: string): Record<string, string> {
+  return Object.fromEntries(emittedAssets.get(outPath) ?? [])
+}
+
+export function clearEmittedAssets(outPath: string): void {
+  emittedAssets.delete(outPath)
+}
+
+/** The file name a logical asset name resolves to. Identity until a build records one. */
+export function emittedAssetName(
+  config: Pick<ResolvedConfig, 'outPath'> | undefined,
+  name: string,
+): string {
+  if (!config?.outPath) return name
+  return emittedAssets.get(config.outPath)?.get(name) ?? name
+}
+
+// Where a built asset lives in the URL space. next-compat serves the build output under Next's
+// static path, so a compat app's document references its CSS/JS exactly as Next does; core keeps
+// `/assets/`. Every document-emitted build-asset URL goes through here (and the dev/prod servers
+// accept both spellings), so an emitted href can never name a path the server will not serve —
+// including the content hash the production name carries.
+export function assetPathname(
+  config: Pick<ResolvedConfig, 'compat' | 'outPath'> | undefined,
+  name: string,
+) {
+  const emitted = emittedAssetName(config, name)
+  return nextCompatEnabled(config ?? {}) ? `/_next/static/${emitted}` : `/assets/${emitted}`
+}
+
+export function assetHref(config: AssetHrefConfig | undefined, name: string) {
+  return withAssetPrefix(config, assetPathname(config, name))
+}
+
+// A route's built CSS filenames - the one rule behind the document's links, the
+// inline-CSS path and analyze, so no consumer can disagree about whether a
+// route has CSS. compat cssChunking records split names in cssAssets.
+export function routeCssAssetNames(
+  route: Pick<RouteManifestEntry, 'id' | 'cssImports' | 'cssAssets'>,
+): string[] {
+  if (route.cssImports.length === 0) return []
+  return route.cssAssets?.length ? route.cssAssets : [`${route.id}.css`]
+}
+
+export function routeCssHref(
+  route: RouteManifestEntry,
+  config?: AssetHrefConfig,
+): string | string[] | undefined {
+  const assets = routeCssAssetNames(route)
+  if (assets.length === 0) return undefined
+  return assets.map(asset => assetHref(config, asset))
+}
+
+/**
+ * Put a render's next/font rules in the first stylesheet chunk, matching Next's
+ * linked CSS delivery without changing the rest of the route's chunk order.
+ */
+export async function emitFontCssStylesheet(
+  config: ResolvedConfig,
+  routeId: string,
+  fontCss: string,
+  baseAsset: string | undefined,
+  options: { dev: boolean },
+) {
+  const outDir = path.join(config.outPath, options.dev ? 'cache' : 'public', 'assets')
+  await ensureDir(outDir)
+  const baseFile = baseAsset ? path.join(outDir, baseAsset) : undefined
+  const baseCss = baseFile && existsSync(baseFile) ? await readFile(baseFile, 'utf8') : ''
+  const contents = [fontCss, baseCss].filter(Boolean).join('\n')
+  const logicalName = baseAsset
+    ? baseAsset.replace(/-[0-9a-f]{16}(?=\.css$)/, '')
+    : `${routeId}.css`
+  const name = hashedAssetName(logicalName, contents)
+  const file = path.join(outDir, name)
+  if (!existsSync(file) || (await readFile(file, 'utf8')) !== contents)
+    await writeFile(file, contents)
+  return name
+}
+
+// Prepend the configured assetPrefix (a CDN origin or path) to an app-absolute
+// asset URL. Link hrefs use basePath instead and must NOT go through here.
+export function withAssetPrefix(
+  config: Pick<ResolvedConfig, 'assetPrefix'> | undefined,
+  href: string,
+) {
+  const prefix = config?.assetPrefix
+  if (!prefix) return href
+  return `${prefix.replace(/\/$/, '')}${href}`
+}
+
+let cssRuntimeRegistered = false
+
+export function registerCssRuntime() {
+  if (cssRuntimeRegistered) return
+  cssRuntimeRegistered = true
+
+  Bun.plugin({
+    name: 'pnext-css-runtime',
+    setup(plugin) {
+      plugin.onLoad({ filter: /\.(?:css|scss|sass)$/ }, async ({ path: file }) =>
+        isCssModuleFile(file)
+          ? {
+              exports: { default: await cssModuleMapping(file) },
+              loader: 'object',
+            }
+          : {
+              contents: 'export default undefined;',
+              loader: 'js',
+            },
+      )
+    },
+  })
+}
+
+// Sass is unsupported (no compiler); its imports still must not break the
+// bundle, so .scss/.sass load as empty modules with module class-name maps.
+export function isCssModuleFile(file: string) {
+  return /\.module\.(?:css|scss|sass)$/.test(file)
+}
+
+export async function cssModuleMapping(file: string) {
+  // Compat handles *.module.{scss,sass} (sass compiles + scopes); core keeps
+  // plain .module.css. Lazy read: the registry populates at compat bootstrap.
+  const compatMapping = getCssExtensions().resolveCssModule(file)
+  if (compatMapping) return compatMapping
+  const source = await readText(file)
+  const classNames = cssClassNames(source)
+
+  return Object.fromEntries(
+    [...classNames].map(className => [className, cssModuleClassName(file, className)]),
+  )
+}
+
+export function cssClassNames(source: string) {
+  const classNames = new Set<string>()
+  const classPattern = /(^|[^\\])\.(-?[_a-zA-Z][\w-]*)/g
+  let match: RegExpExecArray | null
+
+  while ((match = classPattern.exec(source))) {
+    if (match[2]) classNames.add(match[2])
+  }
+
+  return classNames
+}
+
+export function cssModuleClassName(file: string, className: string) {
+  const base = path
+    .basename(file)
+    .replace(/\.module\.css$/, '')
+    .replace(/[^_a-zA-Z0-9]/g, '_')
+  const hash = pathHash(cssModuleScopePath(file))
+  return `${base}_${className}_${hash}`
+}
+
+function pathHash(file: string) {
+  let hash = 5381
+  for (const char of file) hash = ((hash << 5) + hash) ^ char.charCodeAt(0)
+  return (hash >>> 0).toString(36).slice(0, 5)
+}