@thomas.f/prnext 0.1.12-alpha → 0.1.15-alpha

package/build/app.mjs

@@ -118,7 +118,7 @@ function boundaryEntry(boundary) {
   return `import * as client from ${JSON.stringify(boundary.file)};\n` + boundary.exports.map((name, index) => `const ref${index}=client[${JSON.stringify(name)}];export {ref${index} as ${JSON.stringify(name)}};`).join('\n');
 }
 
-function routeEntry(route, globalError) {
+function routeEntry(route, globalError, dev) {
   if (route.kind === 'api') return `export * from ${JSON.stringify(route.file)};`;
   const imports = [`import * as page from ${JSON.stringify(route.file)};`, 'export {page};', `export const pageConfig=${JSON.stringify(route.pageConfig || {})};`];
   const rootLayout = route.segments.find(segment => segment.layout)?.layout;
@@ -144,6 +144,9 @@ function routeEntry(route, globalError) {
   if (route.routing || route.segments.some(segment => segment.error)) imports.push(`export {default as ErrorBoundary} from ${JSON.stringify(path.join(packageRoot, 'compat/app-error-boundary.cjs'))};`);
   if (route.routing) {
     let index = 0;
+    // Only scaffold objects owned by this compiler are immutable. Imported
+    // modules and config values retain their original live bindings/behavior.
+    const structural = source => dev ? source : `Object.freeze(${source})`;
     function serialize(value) {
       const files = [];
       for (const [name, file] of Object.entries(value.files)) {
@@ -151,7 +154,7 @@ function routeEntry(route, globalError) {
         imports.push(`import * as ${binding} from ${JSON.stringify(file)};`);
         files.push(`${JSON.stringify(name)}:${binding}`);
       }
-      return `{path:${JSON.stringify(value.path)},segment:${JSON.stringify(value.segment)},pattern:${JSON.stringify(value.pattern)},layoutId:${JSON.stringify(value.layoutId)},config:${JSON.stringify(value.config || {})},interception:${JSON.stringify(value.interception || null)},files:{${files.join(',')}},children:[${value.children.map(serialize).join(',')}],slots:{${Object.entries(value.slots).map(([name, child]) => `${JSON.stringify(name)}:${serialize(child)}`).join(',')}}}`;
+      return structural(`{path:${JSON.stringify(value.path)},segment:${JSON.stringify(value.segment)},pattern:${JSON.stringify(value.pattern)},layoutId:${JSON.stringify(value.layoutId)},config:${JSON.stringify(value.config || {})},interception:${JSON.stringify(value.interception || null)},files:${structural(`{${files.join(',')}}`)},children:${structural(`[${value.children.map(serialize).join(',')}]`)},slots:${structural(`{${Object.entries(value.slots).map(([name, child]) => `${JSON.stringify(name)}:${serialize(child)}`).join(',')}}`)}}`);
     }
     const routing = serialize(route.routing);
     imports.push(`export const routing=${routing};export const interceptionOnly=${!!route.interceptionOnly};`);
@@ -263,8 +266,17 @@ export async function compileApp({ project, stage, manifest, cssModules, fonts,
           return { path: args.path, namespace: 'prnext-app-empty' };
         });
         esbuild.onLoad({ filter: /.*/, namespace: 'prnext-app-empty' }, () => ({ contents: '', loader: 'js' }));
+        if (rsc) esbuild.onLoad({ filter: /^react$/, namespace: 'prnext-rsc-react' }, () => ({
+          // Keep the real singleton while preserving bundler-style CJS access.
+          // Mixed npm modules may export both server-safe components and unused
+          // hook-based components. Native ESM named imports would reject the
+          // entire module because React's server build has no client hooks.
+          contents: `import React from 'react';export default React;export const {${Object.keys(resolveFromProject('react')).filter(name => t.isValidIdentifier(name) && name !== 'default').join(',')}}=React;`,
+          loader: 'js',
+        }));
         esbuild.onResolve({ filter: /^(?:react|react-dom|react-server-dom-webpack)(?:\/|$)/ }, args => {
           if (args.pluginData?.prnextExportScan) return;
+          if (rsc && args.path === 'react' && args.namespace !== 'prnext-rsc-react') return { path: 'react', namespace: 'prnext-rsc-react' };
           return browser ? { path: resolveFromProject.resolve(args.path) } : { path: args.path, external: true };
         });
         if (!browser) {
@@ -379,6 +391,9 @@ export async function compileApp({ project, stage, manifest, cssModules, fonts,
       define:{...common.define,'process.env.NEXT_RUNTIME':'"nodejs"'},
       chunkNames: 'chunk-[hash]', banner: { js: "import {createRequire as __prnextCreateRequire} from 'node:module';const require=__prnextCreateRequire(import.meta.url);" },
       target: 'node22', conditions: mode === 'rsc' ? ['react-server', 'node'] : ['node'], sourcemap: dev,
+      // Dual-format packages can retain use-client boundaries only in their
+      // ESM distribution (a bundled CommonJS entry can erase those directives).
+      mainFields: mode === 'rsc' ? ['module', 'main'] : ['main', 'module'],
       plugins: [moduleResolutionPlugin(moduleResolution, project.root), images.plugin(), fonts.plugin(), graphPlugin(mode, { styleTarget }), npmPackagesPlugin({ projectRoot: project.root, serverExternalPackages }), nativePackages.plugin(mode), cssModules.plugin(false)],
         });
         if (nativePackages.version !== nativeVersion) {
@@ -446,14 +461,14 @@ export async function compileApp({ project, stage, manifest, cssModules, fonts,
   }
 
   await mkdir(path.join(stage, 'assets'), { recursive: true });
-  const entries = {};
+  const entries = {}, handlerEntries = {};
   for (const route of routes) {
     const entry = path.join(stage, '.entries', route.id + '.server.mjs');
     if ((route.handlerConfig?.runtime === 'edge' || route.cacheConfig?.runtime === 'edge') && manifest.config?.cacheComponents) throw new Error(`Cache Components cannot run in the Edge Runtime (${route.file}).`);
-    await writeFile(entry, routeEntry(route, globalError));
+    await writeFile(entry, routeEntry(route, globalError, dev));
     if (route.cacheConfig?.runtime === 'edge' && route.kind === 'page') await edgeAppBuild(entry, path.join(stage, 'server', route.id + '.mjs'), 'rsc');
     else if (route.handlerConfig?.runtime === 'edge') await compileEdge({ file: route.file, outfile: path.join(stage, 'server', route.id + '.mjs'), projectRoot: project.root, dev, defineEnvironment });
-    else entries[route.id] = entry;
+    else (route.kind === 'api' ? handlerEntries : entries)[route.id] = entry;
     const instantConfigs = [route.pageConfig, ...(route.segments || []).map(segment=>segment.staticConfig)];
     const collectInstant = node => {if(!node)return;instantConfigs.push(...Object.values(node.config || {}));for(const child of [...(node.children || []),...Object.values(node.slots || {})])collectInstant(child);};
     collectInstant(route.routing);
@@ -466,6 +481,9 @@ export async function compileApp({ project, stage, manifest, cssModules, fonts,
   }
   manifest.app = { clientModules: {}, actions: {}, actionKey: actions.actionKey };
   const actionRevision = () => [...actions.actions.values()].map(action=>action.id+':'+[...(action.runtimes || [])].sort().join(',')).join(';');
+  // Route Handlers have a Node React environment and must not share RSC chunks
+  // that import registerServerReference or client-reference registration.
+  await serverBuild(handlerEntries, 'server', 'route');
   for (;;) {
     const revision = `${actionRevision()}:${boundaries.size}:${cssFiles.size}:${globalErrorCssFiles.size}`;
     for (const action of actions.actions.values()) {

package/build/build-lock.mjs

@@ -0,0 +1,71 @@
+import { mkdir, writeFile, rename, rm, realpath, lstat, open } from 'node:fs/promises';
+import { randomUUID } from 'node:crypto';
+import { hostname } from 'node:os';
+import path from 'node:path';
+
+const LOCK = '.prnext-build.lock';
+const busy = message => Object.assign(new Error(message), { code: 'PRNEXT_BUILD_LOCKED' });
+function alive(pid) {
+  try { process.kill(pid, 0); return true; }
+  catch (error) { return error.code !== 'ESRCH'; }
+}
+async function owner(directory) {
+  const info = await lstat(directory);
+  if (!info.isDirectory() || info.isSymbolicLink()) throw busy('The build lock is not a real directory. Check .prnext-build.lock before retrying.');
+  const file = await open(path.join(directory, 'owner.json'), 'r');
+  try {
+    if ((await file.stat()).size > 4096) throw new Error('oversized owner');
+    const value = JSON.parse(await file.readFile('utf8'));
+    if (!Number.isSafeInteger(value.pid) || value.pid < 1 || typeof value.host !== 'string' || !/^[a-f0-9-]{36}$/.test(value.token)) throw new Error('invalid owner');
+    return value;
+  } finally { await file.close(); }
+}
+
+/** One publisher per canonical project, covering React and direct static imports. */
+export async function withBuildLock(directory, action) {
+  const root = await realpath(directory), lock = path.join(root, LOCK);
+  const identity = { pid: process.pid, host: hostname(), token: randomUUID(), createdAt: new Date().toISOString() };
+  const prepared = path.join(root, `.prnext-lock-${identity.token}`);
+  await mkdir(prepared, { mode: 0o700 });
+  try {
+    await writeFile(path.join(prepared, 'owner.json'), JSON.stringify(identity), { flag: 'wx', mode: 0o600 });
+    for (let attempt = 0; ; attempt++) {
+      try { await rename(prepared, lock); break; }
+      catch (error) {
+        if (!['EEXIST', 'ENOTEMPTY', 'EPERM', 'EACCES'].includes(error.code)) throw error;
+        let previous;
+        try { previous = await owner(lock); }
+        catch (cause) {
+          if (cause.code === 'ENOENT' && attempt < 8) continue;
+          throw busy('Cannot verify the build lock. Check .prnext-build.lock before retrying.');
+        }
+        if (previous.host !== identity.host || alive(previous.pid)) throw busy(`A build is already running for this project (PID ${previous.pid}). Wait for it to finish.`);
+        // Exactly one contender can recover this generation. Never delete a lock
+        // merely because it is old: long builds and suspended processes are valid.
+        let claim;
+        try { claim = await open(path.join(lock, 'recovery'), 'wx', 0o600); }
+        catch (cause) {
+          if (cause.code === 'ENOENT' && attempt < 8) continue;
+          throw busy('Build lock recovery is in progress. Retry shortly; if recovery was interrupted, check .prnext-build.lock manually.');
+        }
+        const retired = path.join(root, `.prnext-lock-retired-${identity.token}`);
+        try {
+          await claim.writeFile(JSON.stringify(identity)); await claim.close(); claim = null;
+          const current = await owner(lock);
+          if (current.token !== previous.token) {
+            // Do not unlink through this path: the new owner can release and
+            // another generation can appear between our read and the unlink.
+            throw busy('The build lock changed during recovery. Retry the build.');
+          }
+          await rename(lock, retired);
+          await rm(retired, { recursive: true });
+        } finally { await claim?.close(); }
+      }
+    }
+    try { return await action(root); }
+    finally {
+      // Ownership must still match before releasing a lock.
+      if ((await owner(lock)).token === identity.token) await rm(lock, { recursive: true });
+    }
+  } finally { await rm(prepared, { recursive: true, force: true }); }
+}

package/build/bundle-runtime.mjs

@@ -0,0 +1,82 @@
+import { build } from 'esbuild';
+import { lstat, realpath, readdir, writeFile, unlink } from 'node:fs/promises';
+import path from 'node:path';
+
+// Paths used by the native worker, generated application modules, prerender,
+// standalone tracing, compatibility modules and the runtime lifecycle contract.
+// Other relative imports are resolved into shared chunks by this single build.
+export const runtimeEntryNames = Object.freeze([
+  'worker', 'rsc-worker', 'app-render', 'app-stream-html', 'transport', 'request-work',
+  'http', 'app-static', 'route-static', 'render', 'api', 'middleware', 'incremental-cache', 'app-instant',
+  'action-crypto', 'action-client', 'action-ssr', 'edge', 'metadata-route', 'og-loader',
+].sort());
+
+/** Run once, after compiling application/Edge graphs and before any prerender. */
+export async function bundleRuntime(stage) {
+  const resolvedStage = path.resolve(stage);
+  if (!path.basename(resolvedStage).startsWith('.prnext-build-')) {
+    throw new Error('Runtime bundling requires an unpublished PRNext build stage.');
+  }
+  const runtime = path.join(resolvedStage, 'runtime');
+  const [stageInfo, runtimeInfo] = await Promise.all([lstat(resolvedStage), lstat(runtime)]);
+  if (!stageInfo.isDirectory() || stageInfo.isSymbolicLink() || !runtimeInfo.isDirectory() || runtimeInfo.isSymbolicLink()) {
+    throw new Error('Runtime bundling requires ordinary stage and runtime directories.');
+  }
+  const [canonicalStage, canonicalRuntime] = await Promise.all([realpath(resolvedStage), realpath(runtime)]);
+  if (path.relative(canonicalStage, canonicalRuntime) !== 'runtime') {
+    throw new Error('Runtime bundling escaped the build stage.');
+  }
+  const entries = await readdir(runtime, { withFileTypes: true });
+  const originals = entries.filter(entry => entry.name.endsWith('.mjs'));
+  if (originals.some(entry => !entry.isFile() || entry.isSymbolicLink())) {
+    throw new Error('Runtime source modules must be ordinary files.');
+  }
+  for (const name of runtimeEntryNames) {
+    if (!originals.some(entry => entry.name === `${name}.mjs`)) throw new Error(`Missing runtime entry ${name}.mjs`);
+  }
+  // write:false makes compilation atomic with respect to the source runtime:
+  // no files change if parsing or resolution fails. The virtual output is a
+  // sibling so all relative paths have the same depth as the final runtime.
+  const virtualOutput = path.join(resolvedStage, '.runtime-bundle');
+  const result = await build({
+    absWorkingDir: runtime,
+    entryPoints: runtimeEntryNames.map(name => path.join(runtime, `${name}.mjs`)),
+    outdir: virtualOutput,
+    outbase: runtime,
+    entryNames: '[name]',
+    chunkNames: '_shared-[hash]',
+    outExtension: { '.js': '.mjs' },
+    bundle: true,
+    splitting: true,
+    format: 'esm',
+    platform: 'node',
+    target: 'node22',
+    packages: 'external',
+    // Edge's prepared VM is already a self-contained CJS artifact. Keeping it
+    // external preserves its delayed import and original execution boundary.
+    external: ['../compat/*', './profiles.json', './*.cjs'],
+    minify: false,
+    sourcemap: false,
+    metafile: true,
+    write: false,
+    logLevel: 'silent',
+  });
+  const emitted = new Map();
+  for (const file of result.outputFiles) {
+    if (path.dirname(file.path) !== virtualOutput || !file.path.endsWith('.mjs')) {
+      throw new Error('Runtime bundler emitted a file outside its flat output directory.');
+    }
+    emitted.set(path.basename(file.path), file.contents);
+  }
+  if (runtimeEntryNames.some(name => !emitted.has(`${name}.mjs`))) throw new Error('Runtime bundle omitted a required entry.');
+  // This is an unpublished, disposable stage. On any write failure buildProject
+  // discards the stage and preserves the previous published build unchanged.
+  for (const [name, contents] of emitted) await writeFile(path.join(runtime, name), contents);
+  for (const entry of originals) {
+    if (!emitted.has(entry.name)) await unlink(path.join(runtime, entry.name));
+  }
+  // JSON, CJS, license files and the OG assets directory are never traversed or
+  // removed. The caller writes the normal runtime contract after prerender.
+  return { entryCount: runtimeEntryNames.length, moduleCount: emitted.size,
+    bytes: [...emitted.values()].reduce((sum, contents) => sum + contents.length, 0) };
+}

package/build/compiler.mjs

@@ -12,6 +12,7 @@ import { incrementalBuild } from './incremental.mjs';
 import { webpackGraph } from './webpack-graph.mjs';
 import { turbopackRules, sourceReader } from './turbopack-conditions.mjs';
 import {withSourceMaps,configureSourceMaps,inlineSourceMap} from './source-maps.mjs';
+import { optimizeImportsPlugins } from './optimize-imports.mjs';
 
 let validateOptions;
 const compilation = new AsyncLocalStorage();
@@ -20,7 +21,7 @@ export function configureCompiler(options) { Object.assign(compilation.getStore(
 export async function compilerSource(file, fallback) {
   return compilation.getStore()?.loaded.get(file)?.source ?? fallback ?? await readFile(file, 'utf8');
 }
-const framework = /^(?:prnext-pages-compatibility|prnext-app-(?:rsc|ssr|browser)|prnext-edge-app|prnext-edge|prnext-middleware-compatibility)$/;
+const framework = /^(?:prnext-pages-compatibility|prnext-app-(?:rsc|ssr|browser|route)|prnext-edge-app|prnext-edge|prnext-middleware-compatibility)$/;
 function condition(value, input) {
   if (value === undefined) return true;
   if (value instanceof RegExp) { value.lastIndex = 0; return value.test(input); }
@@ -120,6 +121,7 @@ export async function validateCompilerConfig(config, root, {dev=false,edge=false
 }
 export async function build(options) {
   const state = compilation.getStore();
+  if ((options.plugins || []).some(plugin => framework.test(plugin.name))) options = { ...options, plugins: optimizeImportsPlugins(options.plugins, state?.config?.experimental?.optimizePackageImports) };
   // esbuild's shared service dispatches callbacks from its own async context.
   // Re-enter this build so transforms never inherit another project's map mode,
   // action registry or configuration from the first service invocation.

package/build/config.mjs

@@ -17,6 +17,8 @@ import { validateI18n } from './i18n.mjs';
 import { frameworkPackages } from './framework-imports.mjs';
 import { validateTypeScript } from './typescript.mjs';
 import { validateWorkerRetirement } from './worker-retirement.mjs';
+import { validateOptimizePackageImports } from './optimize-imports.mjs';
+import { validateProxyBodySize } from './proxy-body-config.mjs';
 
 const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 const configName = /^(?:next|prnext)\.config\.(?:js|mjs|cjs|ts)$/;
@@ -29,6 +31,7 @@ supported.add('turbopack');
 supported.add('i18n');
 supported.add('webpack');
 supported.add('onDemandEntries');
+supported.add('devIndicators');
 for (const key of ['reactCompiler', 'typedRoutes', 'typescript']) supported.add(key);
 for (const key of ['output', 'outputFileTracingRoot', 'outputFileTracingIncludes', 'outputFileTracingExcludes']) supported.add(key);
 
@@ -89,6 +92,7 @@ export function validateProjectConfig(input, filename = 'project config') {
   }
   config.typescript = validateTypeScript(config.typescript);
   config.workerRetirement = validateWorkerRetirement(config.workerRetirement);
+  if (config.devIndicators !== undefined && config.devIndicators !== false) throw new TypeError('devIndicators currently supports only false. PRNext provides development errors and Fast Refresh, but no Next.js development indicator menu.');
   if (config.onDemandEntries !== undefined) {
     const entries = config.onDemandEntries;
     if (!entries || typeof entries !== 'object' || Array.isArray(entries)) throw new TypeError('onDemandEntries must be an object');
@@ -117,14 +121,17 @@ export function validateProjectConfig(input, filename = 'project config') {
     config[key] = [...new Set(names)];
   }
   for (const name of config.transpilePackages) if (config.serverExternalPackages.includes(name)) throw new Error(`${filename}: ${name} cannot be in both transpilePackages and serverExternalPackages.`);
+  // Like Next, retain pg's Node module boundary: its optional pg-native getter
+  // must resolve lazily, not be traversed by the RSC/server bundler at build.
+  if (!config.transpilePackages.includes('pg') && !config.serverExternalPackages.includes('pg')) config.serverExternalPackages.push('pg');
   if (config.sassOptions !== undefined && (!config.sassOptions || typeof config.sassOptions !== 'object' || Array.isArray(config.sassOptions))) throw new Error(`${filename}: sassOptions must be an object.`);
   if (!config.experimental || typeof config.experimental !== 'object' || Array.isArray(config.experimental)) throw new Error(`${filename}: experimental must be an object.`);
   for (const key of Object.keys(config.experimental)) {
-    if (!['nextScriptWorkers', 'serverActions'].includes(key)) throw new Error(`${filename}: experimental.${key} is not supported by PRNext. It cannot be silently ignored.`);
+    if (!['nextScriptWorkers', 'serverActions', 'optimizePackageImports', 'proxyClientMaxBodySize'].includes(key)) throw new Error(`${filename}: experimental.${key} is not supported by PRNext. It cannot be silently ignored.`);
   }
   const nextScriptWorkers = config.experimental.nextScriptWorkers === undefined ? false : config.experimental.nextScriptWorkers;
   if (typeof nextScriptWorkers !== 'boolean') throw new Error(`${filename}: experimental.nextScriptWorkers must be a boolean.`);
-  config.experimental = { nextScriptWorkers, serverActions: validateServerActions(config.experimental.serverActions) };
+  config.experimental = { nextScriptWorkers, serverActions: validateServerActions(config.experimental.serverActions), optimizePackageImports: validateOptimizePackageImports(config.experimental.optimizePackageImports), proxyClientMaxBodySize: validateProxyBodySize(config.experimental.proxyClientMaxBodySize) };
   for (const key of ['basePath', 'assetPrefix']) {
     if (typeof config[key] !== 'string' || Buffer.byteLength(config[key]) > 4096) throw new Error(`${filename}: ${key} must be a string of at most 4096 bytes.`);
   }

package/build/font-cache.mjs

@@ -0,0 +1,50 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { mkdir, readFile, writeFile, rename, rm, readdir, lstat } from 'node:fs/promises';
+import path from 'node:path';
+
+const hash = value => createHash('sha256').update(value).digest('hex');
+const MAX_TOTAL = 64 * 1024 * 1024;
+let writes = Promise.resolve();
+
+/** Project-local build inputs, never responses/user data. Clearing this directory
+ * refreshes Google assets. A warm cache also permits an offline rebuild.
+ */
+export async function cachedFontResource(root, url, maximum, accept, download) {
+  if (!root) return download();
+  const directory = path.join(root, '.prnext-cache', 'fonts-v1');
+  const file = path.join(directory, hash(JSON.stringify([url, accept])) + '.bin');
+  try {
+    const metadata = await lstat(file);
+    if (metadata.isFile() && metadata.size > 65 && metadata.size <= maximum + 65) {
+      const stored = await readFile(file);
+      const bytes = stored.subarray(65);
+      if (stored[64] === 10 && hash(bytes) === stored.toString('ascii', 0, 64)) return bytes;
+    }
+  } catch (error) { if (!['ENOENT', 'ENOTDIR', 'EACCES'].includes(error.code)) throw error; }
+  const bytes = await download();
+  if (!bytes.length || bytes.length > maximum) throw new Error('Font resource exceeds its cache input limit');
+  const task = writes.catch(() => {}).then(async () => {
+    await mkdir(directory, { recursive: true });
+    const temporary = file + '.' + randomUUID() + '.tmp';
+    try {
+      await writeFile(temporary, Buffer.concat([Buffer.from(hash(bytes) + '\n'), bytes]), { flag: 'wx' });
+      await rename(temporary, file);
+    } finally { await rm(temporary, { force: true }); }
+    const entries = [];
+    for (const item of await readdir(directory, { withFileTypes: true })) {
+      if (!item.isFile() || !/^[a-f0-9]{64}\.bin$/.test(item.name)) continue;
+      try { entries.push({ file: path.join(directory, item.name), ...await lstat(path.join(directory, item.name)) }); }
+      catch (error) { if (error.code !== 'ENOENT') throw error; }
+    }
+    entries.sort((a, b) => b.mtimeMs - a.mtimeMs);
+    let total = 0;
+    for (let index = 0; index < entries.length; index++) {
+      total += entries[index].size;
+      if (index >= 256 || total > MAX_TOTAL) await rm(entries[index].file, { force: true });
+    }
+  });
+  writes = task;
+  try { await task; }
+  catch (error) { if (!['EACCES', 'EPERM', 'EROFS', 'ENOSPC', 'ENOENT'].includes(error.code)) throw error; }
+  return bytes;
+}

package/build/font-files.mjs

@@ -2,6 +2,7 @@ import { readFile, writeFile, mkdir, stat } from 'node:fs/promises';
 import path from 'node:path';
 import { createHash } from 'node:crypto';
 import googleFonts from './font-data.json' with { type: 'json' };
+import { cachedFontResource } from './font-cache.mjs';
 
 const formats = { woff: 'woff', woff2: 'woff2', ttf: 'truetype', otf: 'opentype', eot: 'embedded-opentype' };
 const types = { woff: 'font/woff', woff2: 'font/woff2', ttf: 'font/ttf', otf: 'font/otf', eot: 'application/vnd.ms-fontobject' };
@@ -36,7 +37,7 @@ function validate(kind, options) {
 }
 
 async function responseBytes(url, maximum, accept) {
-  const response = await fetch(url, { signal: AbortSignal.timeout(15_000), headers: { accept,
+  const response = await fetch(url, { signal: AbortSignal.timeout(15_000), redirect: 'error', headers: { accept,
     'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36' } });
   if (!response.ok) { await response.body?.cancel(); fail(`Unable to download ${url}: HTTP ${response.status}.`); }
   if (Number(response.headers.get('content-length')) > maximum) { await response.body?.cancel(); fail(`Font resource exceeds ${maximum} bytes.`); }
@@ -145,7 +146,8 @@ function googleOptions(name, options) {
 
 async function google(name, options, context) {
   const normalized = googleOptions(name, options);
-  const css = (await responseBytes(normalized.url, 1024 * 1024, 'text/css')).toString('utf8');
+  const resourceBytes = (url, maximum, accept) => cachedFontResource(context.projectRoot, url, maximum, accept, () => responseBytes(url, maximum, accept).catch(error => { throw new Error(`next/font: download failed for ${url}: ${error.message}. An initial build needs access to Google Fonts; subsequent builds can reuse .prnext-cache/fonts-v1.`, { cause: error }); }));
+  const css = (await resourceBytes(normalized.url, 1024 * 1024, 'text/css')).toString('utf8');
   const faces = [], downloaded = new Map();
   let total = 0;
   const facePattern = /(?:\/\*\s*([^*]+?)\s*\*\/\s*)?@font-face\s*\{([^}]+)\}/g;
@@ -161,7 +163,7 @@ async function google(name, options, context) {
       if (url.protocol !== 'https:' || url.hostname !== 'fonts.gstatic.com' || url.username || url.password) fail('Google font CSS referenced an unexpected font origin.');
       if (!downloaded.has(url.href)) {
         if (downloaded.size >= 64) fail('Google font call exceeds 64 files.');
-        const bytes = await responseBytes(url.href, MAX_FONT, 'font/woff2,font/woff,*/*');
+        const bytes = await resourceBytes(url.href, MAX_FONT, 'font/woff2,font/woff,*/*');
         total += bytes.length;
         if (total > 64 * 1024 * 1024) fail('Google font call exceeds 64 MiB.');
         const ext = path.extname(url.pathname).slice(1).toLowerCase();

package/build/fonts.mjs

@@ -37,7 +37,7 @@ export function createFonts({ projectRoot, stage, assetBase }) {
   async function prepare(kind, name, options, file, position) {
     const id = hash(JSON.stringify([path.relative(projectRoot, file), position, kind, name, options]));
     if (!compilations.has(id)) compilations.set(id, (async () => {
-      const compiled = await compileFont({ kind, name, options, file, id, stage, assetBase });
+      const compiled = await compileFont({ kind, name, options, file, id, stage, assetBase, projectRoot });
       const moduleFile = path.join(stage, '.entries', `font-${id}.mjs`);
       const cssFile = path.join(stage, '.entries', `font-${id}.css`);
       await mkdir(path.dirname(moduleFile), { recursive: true });

package/build/index.mjs

@@ -1,5 +1,7 @@
 import { rename } from '../runtime/fs.mjs';
 import { writeRuntimeContract } from './runtime-contract.mjs';
+import { writeBuildOutput } from './output-contract.mjs';
+import { bundleRuntime } from './bundle-runtime.mjs';
 import {frameworkImportName, frameworkRuntimeImportPattern} from './framework-imports.mjs';
 import { expandLocales, localizedStaticPaths } from './i18n.mjs';
 import { build as bundle, withCompilation, configureCompiler, compilerSource } from './compiler.mjs';
@@ -19,6 +21,7 @@ import { createImages } from './images.mjs';
 import { compileApp } from './app.mjs';
 import { prerenderApp } from './app-static.mjs';
 import { precompressBuild } from './precompress.mjs';
+import { withBuildLock } from './build-lock.mjs';
 import { loadProjectConfig, defineEnvironment, generateBuildId, publicAssetBase } from './config.mjs';
 import { compileCustomRoutes } from './custom-routes.mjs';
 import { compileMiddleware } from './middleware.mjs';
@@ -185,10 +188,13 @@ let buildQueue = Promise.resolve();
 /** Isolate process.env between programmatic builds, including simultaneous calls. */
 export function build(projectRoot, options = {}) {
   const task = buildQueue.then(async () => {
+    if (options.adapter === 'static') return (await import('./static-adapter.mjs')).buildStatic(projectRoot, options);
+    if (options.adapter !== undefined && options.adapter !== 'react') throw new Error(`Unknown PRNext adapter: ${options.adapter}`);
+    if (options.from !== undefined || options.spa !== undefined) throw new Error('from and spa are only supported by the static adapter.');
     const restore = snapshotEnvConfig();
     const envMode = options.envMode || (process.env.NODE_ENV === 'test' ? 'test' : options.dev ? 'development' : 'production');
     process.env.NODE_ENV = options.dev ? 'development' : 'production';
-    try { return await withCompilation(() => buildProject(projectRoot, { ...options, envMode })); }
+    try { return await withBuildLock(projectRoot, root => withCompilation(() => buildProject(root, { ...options, envMode }))); }
     finally { restore(); }
   });
   buildQueue = task.catch(() => {});
@@ -294,11 +300,15 @@ async function buildProject(projectRoot, { dev = false, envMode, incremental = f
       }
     }
     await compileMiddleware({ project, stage, manifest, dev, moduleResolution: config.turbopack, defineEnvironment: environment });
+    if (manifest.middleware) manifest.middleware.bodySizeLimit = config.experimental.proxyClientMaxBodySize;
     await prepareMetadataRoutes(project, stage);
     await compileApp({ project, stage, manifest, moduleResolution: config.turbopack, cssModules, fonts, images, dev, defineEnvironment: environment, productionBrowserSourceMaps: config.productionBrowserSourceMaps, serverExternalPackages: config.serverExternalPackages });
     await checkTypeScript(project.root, config, { dev, tsconfig });
     fonts.attach(manifest);
     expandLocales(manifest);
+    // All runtime preparation must finish before its shared modules are built;
+    // no staged renderer has been imported before this production-only point.
+    if (!dev) await bundleRuntime(stage);
     await prerender(stage, manifest, dev);
     await prerenderApp(stage, manifest, dev);
     const pages = manifest.routes.filter(route => route.kind === 'page' && route.router !== 'app' && !route.internal);
@@ -330,6 +340,7 @@ async function buildProject(projectRoot, { dev = false, envMode, incremental = f
     }
     await writeRuntimeContract(stage);
     await writeFile(path.join(stage, 'manifest.json'), JSON.stringify(manifest, null, 2) + '\n');
+    await writeBuildOutput(stage, manifest);
     if (config.compress) await precompressBuild(stage, manifest, {cacheDirectory:path.join(project.root,'.prnext-cache/precompress-v1')});
     if (config.output === 'standalone' && !dev) await (await import('./standalone-runner.mjs')).prepareStandalone({ projectRoot: project.root, stage, manifest, config });
     const exporting = config.output === 'export' && !dev ? await import('./static-export.mjs') : null;

package/build/inspect.mjs

@@ -1,6 +1,8 @@
-import { readFile, readdir, stat } from 'node:fs/promises';
+import { readFile, readdir, stat, open } from 'node:fs/promises';
 import path from 'node:path';
 import { readBuildDirectory } from '../runtime/build-directory.mjs';
+import { summarizeDiagnostics, inspectionMetrics } from './inspection-summary.mjs';
+export { inspectionMetrics };
 
 export function explainRoute(route, manifest) {
   const seeds = manifest.prerendered.filter(seed => seed.routeId === route.id || (!seed.routeId && seed.path === route.pattern));
@@ -27,6 +29,18 @@ export async function inspectProject(directory) {
   try { manifest = JSON.parse(await readFile(path.join(root, output, 'manifest.json'), 'utf8')); }
   catch (error) { throw new Error(`Cannot read a build in ${root}. Run prn build first.`, { cause: error }); }
   const folder = path.join(root, '.prnext-cache/inspect');
+  const runtime = [];
+  for (const name of (await readdir(folder).catch(error => {if(error.code==='ENOENT')return [];throw error;})).filter(name => /^metrics-\d+\.jsonl$/.test(name)).slice(-8)) {
+    let file;
+    try {
+      file = await open(path.join(folder,name),'r');
+      const info = await file.stat(), bytes = Buffer.alloc(Math.min(info.size,65536));
+      await file.read(bytes,0,bytes.length,Math.max(0,info.size-bytes.length));
+      for (const line of bytes.toString().split('\n').reverse()) {
+        try { const value=JSON.parse(line);if(Number.isFinite(value.unixMs)&&value.workers){runtime.push(value);break;} } catch {}
+      }
+    } catch {} finally {await file?.close();}
+  }
   let names = [];
   try { names = (await readdir(folder)).filter(name => /^(?:worker-\d+-\d+|native-\d+)\.jsonl(?:\.1)?$/.test(name)); }
   catch (error) { if (error.code !== 'ENOENT') throw error; }
@@ -50,7 +64,7 @@ export async function inspectProject(directory) {
     durations.sort((a, b) => a - b);
     return { ...group, ...(durations.length ? { meanMs: Math.round(durations.reduce((a, b) => a + b, 0) / durations.length * 100) / 100, p95Ms: durations[Math.ceil(durations.length * .95) - 1], maxMs: durations.at(-1) } : {}) };
   }).sort((a, b) => (b.p95Ms || 0) - (a.p95Ms || 0));
-  return { version: 1, root, buildId: manifest.buildId, routes: manifest.routes.filter(route => !route.internal).map(route => explainRoute(route, manifest)),
+  return { version: 1, root, buildId: manifest.buildId, ...summarizeDiagnostics(recent,runtime), routes: manifest.routes.filter(route => !route.internal).map(route => explainRoute(route, manifest)),
     measurements, cacheEntries: [...entries.values()].slice(-100), invalidations: recent.filter(event => event.type === 'invalidation').slice(-50), dynamicUsage: recent.filter(event => event.type === 'dynamic').slice(-50),
     sample: { events: recent.length, from: recent[0]?.time, to: recent.at(-1)?.time },
     notes: ['Enable measurements with prn start --inspect (or prn dev --inspect), visit routes, then run prn inspect again.',
@@ -59,6 +73,10 @@ export async function inspectProject(directory) {
 }
 export function printInspection(report) {
   console.log(`PRNext inspector: ${report.root}`);
+  console.log(`Recorded sample: ${report.summary.requests} HTTP requests; p50 ${report.summary.p50Ms ?? 'n/a'} ms; p95 ${report.summary.p95Ms ?? 'n/a'} ms (response headers); ${report.summary.errors} server errors.`);
+  if(report.summary.wakeP95Ms !== null) console.log(`Worker startup p95: ${report.summary.wakeP95Ms} ms.`);
+  if(report.summary.workerRssBytes !== null) console.log(`Latest recorded worker RSS: ${(report.summary.workerRssBytes/1048576).toFixed(1)} MiB. Native server memory is not included.`);
+  for(const finding of report.findings)console.log(`${finding.level.toUpperCase()}: ${finding.message} ${finding.action}`);
   for (const route of report.routes) console.log(`${route.mode.padEnd(13)} ${route.pattern}\n  ${route.reasons.join('; ') || `${route.prerenderedPaths} prerendered path(s); revalidate: ${route.revalidate.join(', ') || 'on demand'}`}`);
   for (const item of report.measurements) console.log(`${item.type.toUpperCase()} ${item.route}${item.destination ? ' -> ' + item.destination : ''}: ${item.count} sample(s)${item.state ? ', ' + item.state : ''}${item.reason ? ' (' + item.reason + ')' : ''}${item.p95Ms !== undefined ? ', p95 ' + item.p95Ms.toFixed(2) + ' ms' : ''}, ${item.errors} error(s)`);
   for (const event of report.invalidations) console.log(`INVALIDATION ${event.route}: ${event.mode}; tags ${(event.tags || []).join(', ') || 'none'}; paths ${(event.paths || []).join(', ') || 'none'}`);

package/build/inspection-summary.mjs

@@ -0,0 +1,37 @@
+const quantile = (values, q) => values.length ? Math.round([...values].sort((a,b)=>a-b)[Math.ceil(values.length*q)-1]*100)/100 : null;
+const durations = events => events.map(e=>e.durationMs).filter(v=>Number.isFinite(v)&&v>=0);
+export function summarizeDiagnostics(events, snapshots = []) {
+  const http=events.filter(e=>e.type==='http'), times=durations(http);
+  const wake=durations(events.filter(e=>e.type==='wake'&&e.phase==='node-ready'));
+  const processes=new Map();
+  for(const event of events)if(event.type==='process'&&Number.isSafeInteger(event.pid)&&Number.isFinite(event.rssBytes)&&event.rssBytes>=0)processes.set(event.pid,event);
+  const last=snapshots.sort((a,b)=>b.unixMs-a.unixMs)[0];
+  const current=last&&Date.now()-last.unixMs<30000&&Date.now()>=last.unixMs;
+  const rss=[...processes.values()].filter(e=>Date.now()-e.time<30000&&Date.now()>=e.time);
+  const summary={requests:http.length,errors:http.filter(e=>e.status>=500).length,p50Ms:quantile(times,.5),p95Ms:quantile(times,.95),wakeP95Ms:quantile(wake,.95),workerRssBytes:rss.length?rss.reduce((n,e)=>n+e.rssBytes,0):null,
+    queuedJobs:current?last.workers.queuedJobs??null:null,activeJobs:current?last.workers.activeJobs??null:null, runtimeSampleAt:last?.unixMs??null};
+  const findings=[];
+  if(!http.length)findings.push({level:'info',code:'NO_SAMPLE',message:'No HTTP sample recorded.',action:'Start with --inspect, visit the site and run inspect again.'});
+  if(summary.queuedJobs>0)findings.push({level:'warning',code:'WORKER_QUEUE',message:`${summary.queuedJobs} jobs are waiting for a worker.`,action:'Check slow routes and available CPU/RAM before increasing concurrency.'});
+  if(summary.p95Ms>=1000)findings.push({level:'warning',code:'SLOW_HEADERS',message:'The slowest 5% of recorded responses take at least one second to prepare headers.',action:'Inspect route and fetch timings below; this includes queueing and startup.'});
+  if(summary.errors)findings.push({level:'warning',code:'SERVER_ERRORS',message:`${summary.errors} recorded requests returned a server error.`,action:'Check application logs for the same sample period.'});
+  if(summary.wakeP95Ms>=1000)findings.push({level:'info',code:'SLOW_WAKE',message:'Recorded worker startup p95 exceeds one second.',action:'Review startup imports or use keep-warm if the extra memory is acceptable.'});
+  return {summary,findings,metricSample:http.filter(e=>Number.isFinite(e.durationMs)&&e.durationMs>=0&&e.durationMs<=86400000&&Number.isSafeInteger(e.time)&&e.time>=0&&e.time<=18446744073709).map(e=>({route:typeof e.route==='string'?e.route.slice(0,256):'<unmatched>',method:/^(GET|HEAD|POST|PUT|PATCH|DELETE|OPTIONS|CONNECT|TRACE)$/.test(e.method)?e.method:'_OTHER',durationMs:e.durationMs,time:e.time}))};
+}
+
+/** OTLP/JSON Metrics export of a bounded local sample, never a complete traffic counter. */
+export function inspectionMetrics(report) {
+  const bounds=[.001,.005,.01,.025,.05,.1,.25,.5,1,2.5,5,10], groups=new Map();
+  for(const event of report.metricSample||[]) {
+    const key=JSON.stringify([event.route,event.method]);
+    if(!groups.has(key))groups.set(key,{route:event.route,method:event.method,values:[],start:event.time,end:event.time});
+    const group=groups.get(key);group.values.push(event.durationMs/1000);group.start=Math.min(group.start,event.time);group.end=Math.max(group.end,event.time);
+  }
+  const dataPoints=[...groups.values()].map(group=>{
+    const buckets=Array(bounds.length+1).fill(0);
+    for(const value of group.values){const index=bounds.findIndex(bound=>value<=bound);buckets[index<0?bounds.length:index]++;}
+    return {attributes:[{key:'http.route',value:{stringValue:group.route}},{key:'http.request.method',value:{stringValue:group.method}}],
+      startTimeUnixNano:String(BigInt(Math.trunc(group.start))*1000000n),timeUnixNano:String(BigInt(Math.trunc(group.end))*1000000n),count:String(group.values.length),sum:group.values.reduce((a,b)=>a+b,0),min:Math.min(...group.values),max:Math.max(...group.values),explicitBounds:bounds,bucketCounts:buckets.map(String)};
+  });
+  return {resourceMetrics:[{resource:{attributes:[{key:'service.name',value:{stringValue:'prnext'}},{key:'prnext.inspect.sampled',value:{boolValue:true}}]},scopeMetrics:[{scope:{name:'prnext.inspect',version:'1'},metrics:[{name:'prnext.http.response.headers.duration',description:'Bounded diagnostic sample of time until response headers; excludes response body streaming.',unit:'s',histogram:{aggregationTemporality:1,dataPoints}}]}]}]};
+}

package/build/metadata-conflicts.mjs

@@ -0,0 +1,13 @@
+import { readFile, stat } from 'node:fs/promises';
+import path from 'node:path';
+
+export async function validatePublicMetadata(root, pattern, file, dynamic) {
+  const publicFile = path.join(root, 'public', pattern.slice(1));
+  try {
+    const info = await stat(publicFile);
+    // Next production serves public files before App metadata handlers. An
+    // identical static duplicate is therefore unambiguous and safe to retain.
+    if (!dynamic && info.isFile() && info.size <= 16 * 1024 * 1024 && info.size === (await stat(file)).size && (await readFile(publicFile)).equals(await readFile(file))) return;
+    throw new Error(`Metadata route ${pattern} conflicts with a different file in public/. Keep a single source for this URL.`);
+  } catch (error) { if (error.code !== 'ENOENT' && error.code !== 'ENOTDIR') throw error; }
+}

package/build/metadata-images.mjs

@@ -1,4 +1,4 @@
-import { readFile, access } from 'node:fs/promises';
+import { readFile } from 'node:fs/promises';
 import path from 'node:path';
 import { createHash } from 'node:crypto';
 import { execFile } from 'node:child_process';
@@ -7,6 +7,7 @@ import { resolveNativeBinary } from '../native/resolve.mjs';
 import { validateAppConfig, mergeAppConfig } from './app-config.mjs';
 import { metadataExportNames } from './metadata-routes.mjs';
 import { pageExtensionPattern, validatePageSource } from './page-extensions.mjs';
+import { validatePublicMetadata } from './metadata-conflicts.mjs';
 const execute = promisify(execFile);
 const contentTypes = { ico: 'image/x-icon', png: 'image/png', jpg: 'image/jpeg', jpeg: 'image/jpeg', svg: 'image/svg+xml', gif: 'image/gif' };
 const imageTypes = { favicon: ['ico'], icon: ['ico', 'jpg', 'jpeg', 'png', 'svg'], 'apple-icon': ['jpg', 'jpeg', 'png'], 'opengraph-image': ['jpg', 'jpeg', 'png', 'gif'], 'twitter-image': ['jpg', 'jpeg', 'png', 'gif'] };
@@ -57,8 +58,7 @@ export async function scanMetadataImages({ root, appRoot, files, routes, pattern
     const pattern = validatePattern([...urlParts, filename, ...(multiple ? ['[__metadata_id__]'] : [])], relative);
     const signature = pattern.replace(/\[[^\]]+\]/g, '[]');
     if (patterns.has(signature)) throw new Error(`Conflicting metadata route ${relative} and ${patterns.get(signature)} at ${pattern}.`);
-    try { await access(path.join(root, 'public', pattern.slice(1))); throw new Error(`Metadata route ${pattern} conflicts with a file in public/.`); }
-    catch (error) { if (error.code !== 'ENOENT' && error.code !== 'ENOTDIR') throw error; }
+    await validatePublicMetadata(root, pattern, file, dynamic);
     patterns.set(signature, relative);
     const handlerConfig = dynamic ? await validateAppConfig(file) : {};
     handlerConfig.revalidate ??= false;

package/build/metadata-routes.mjs

@@ -1,10 +1,11 @@
-import { readFile, writeFile, access } from 'node:fs/promises';
+import { readFile, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 import { createHash } from 'node:crypto';
 import { parse } from '@babel/parser';
 import { validateAppConfig, mergeAppConfig } from './app-config.mjs';
 import { scanMetadataImages } from './metadata-images.mjs';
 import { pageExtensionPattern, validatePageSource } from './page-extensions.mjs';
+import { validatePublicMetadata } from './metadata-conflicts.mjs';
 
 const contentTypes = { robots: 'text/plain', sitemap: 'application/xml', manifest: 'application/manifest+json' };
 
@@ -31,8 +32,7 @@ export async function scanMetadataRoutes({ root, appRoot, files, routes, pattern
     const signature = pattern.replace(/\[[^\]]+\]/g, '[]');
     if (patterns.has(signature)) throw new Error(`Conflicting metadata route ${relative} and ${patterns.get(signature)} at ${pattern}.`);
     if (kind === 'manifest' && manifest) throw new Error('Multiple manifest metadata files found in the App Router root.');
-    try { await access(path.join(root, 'public', pattern.slice(1))); throw new Error(`Metadata route ${pattern} conflicts with a file in public/.`); }
-    catch (error) { if (error.code !== 'ENOENT' && error.code !== 'ENOTDIR') throw error; }
+    await validatePublicMetadata(root, pattern, file, dynamic);
     patterns.set(signature, relative);
     const handlerConfig = dynamic ? await validateAppConfig(file) : {};
     if (dynamic) {