@thomas.f/prnext 0.1.11-alpha → 0.1.13-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) {
@@ -446,14 +458,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 +478,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/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/cache-handlers.mjs

@@ -2,6 +2,7 @@ import { build } from 'esbuild';
 import { createRequire } from 'node:module';
 import path from 'node:path';
 import {frameworkImportName} from './framework-imports.mjs';
+import { projectTsconfig } from './typescript.mjs';
 
 export function validateCacheHandler(input) {
   if (input === undefined) return undefined;
@@ -11,7 +12,7 @@ export function validateCacheHandler(input) {
 
 export async function prepareCacheHandler(options) {
   if (!options.config.cacheHandler) return undefined;
-  const handlers = await prepareCacheHandlers({ ...options, config: { cacheHandlers: { __legacy: options.config.cacheHandler } } });
+  const handlers = await prepareCacheHandlers({ ...options, config: { ...options.config, cacheHandlers: { __legacy: options.config.cacheHandler } } });
   return handlers.__legacy;
 }
 
@@ -33,6 +34,7 @@ export function validateCacheHandlers(input) {
 export async function prepareCacheHandlers({ config, projectRoot, stage, environment = {} }) {
   const result = {};
   const compiled = new Map();
+  const tsconfig = config.typescript ? await projectTsconfig(projectRoot, config) : undefined;
   const require = createRequire(path.join(projectRoot, 'package.json'));
   for (const [name, source] of Object.entries(config.cacheHandlers || {})) {
     let entry;
@@ -41,6 +43,7 @@ export async function prepareCacheHandlers({ config, projectRoot, stage, environ
     if (compiled.has(entry)) { result[name] = compiled.get(entry); continue; }
     const output = `server/cache-handler-${name}.mjs`;
     await build({ absWorkingDir: projectRoot, entryPoints: [entry], outfile: path.join(stage, output), bundle: true,
+      ...(tsconfig ? { tsconfig } : {}),
       platform: 'node', target: 'node22', format: 'esm', packages: 'external', logLevel: 'silent', define: environment,
       banner: { js: "import {createRequire as __prnextCreateRequire} from 'node:module';const require=__prnextCreateRequire(import.meta.url);" },
       plugins: [{ name: 'cache-handler-compatibility', setup(builder) {

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.
@@ -134,6 +136,7 @@ export async function build(options) {
   }}))};
   // Runtime vendor bundles are framework-owned, not project webpack targets.
   const projectGraph = (options.plugins || []).some(plugin => framework.test(plugin.name));
+  if (projectGraph && state?.tsconfig) options = { ...options, tsconfig: state.tsconfig };
   const compile = input => state?.incremental && state.dev && (projectGraph || !input.plugins?.length) ? incrementalBuild(input,{root:state.root,stage:state.stage,group:projectGraph?'project':'auxiliary',run:callback=>compilation.run(state,callback)}) : esbuild(input);
   if (!(state?.config?.webpack || Object.keys(state?.config?.turbopack?.rules || {}).length) || !projectGraph) return compile(options);
   const target = options.define?.['process.env.NEXT_RUNTIME'] === '"edge"' ? 'edge' : options.platform === 'browser' ? 'browser' : 'node';

package/build/config.mjs

@@ -15,17 +15,24 @@ import { validateStandaloneConfig } from './standalone-config.mjs';
 import { validateTurbopack } from './module-resolution.mjs';
 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)$/;
 const supported = new Set(['env', 'redirects', 'headers', 'rewrites', 'generateBuildId', 'compress', 'poweredByHeader', 'productionBrowserSourceMaps', 'basePath', 'assetPrefix', 'experimental', 'sassOptions', 'transpilePackages', 'serverExternalPackages', 'cacheComponents', 'cacheLife', 'images', 'reactStrictMode', 'pageExtensions', 'trailingSlash', 'skipTrailingSlashRedirect', 'skipMiddlewareUrlNormalize', 'skipProxyUrlNormalize', 'cacheHandlers', 'distDir']);
 const defaults = { distDir: '.prnext', env: {}, compress: true, poweredByHeader: true, productionBrowserSourceMaps: false, basePath: '', assetPrefix: '', trailingSlash: false, skipTrailingSlashRedirect: false, skipMiddlewareUrlNormalize: false, experimental: { nextScriptWorkers: false } };
 supported.add('cacheHandler');
+supported.add('workerRetirement');
 supported.add('cacheMaxMemorySize');
 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);
 
 function validPrefixPath(value, where, { root = false } = {}) {
@@ -78,6 +85,14 @@ export function validateProjectConfig(input, filename = 'project config') {
   // Optional properties explicitly set to undefined still use their defaults,
   // as in common process.env-based Next configuration wrappers.
   const config = { ...defaults, ...Object.fromEntries(Object.entries(input).filter(([,value]) => value !== undefined)) };
+  for (const key of ['reactCompiler', 'typedRoutes']) {
+    if (config[key] === undefined || config[key] === false) continue;
+    if (key === 'reactCompiler') throw new Error('reactCompiler currently supports only false. PRNext does not run the React Compiler transform; keep Next.js for builds that require it.');
+    throw new Error('typedRoutes currently supports only false. PRNext does not generate or validate typed route declarations; keep Next.js for builds that require them.');
+  }
+  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');
@@ -106,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,4 +1,6 @@
 import { rename } from '../runtime/fs.mjs';
+import { writeRuntimeContract } from './runtime-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';
@@ -29,6 +31,7 @@ import { npmPackagesPlugin } from './npm-packages.mjs';
 import { createRefreshTransform, devSingletonsPlugin, devClientFile } from './dev.mjs';
 import { snapshotEnvConfig } from '../runtime/env.mjs';
 import { validateStaticPaths } from '../runtime/pages-paths.mjs';
+import { projectTsconfig, checkTypeScript } from './typescript.mjs';
 export { staticPath } from '../runtime/pages-paths.mjs';
 
 const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
@@ -197,6 +200,7 @@ export function build(projectRoot, options = {}) {
 async function buildProject(projectRoot, { dev = false, envMode, incremental = false, devInputs } = {}) {
   const started = performance.now();
   const config = await loadProjectConfig(projectRoot, { dev, envMode });
+  const tsconfig = config.typescript ? await projectTsconfig(projectRoot, config) : undefined;
   const environment = defineEnvironment(config);
   const publicPaths = { trailingSlash: config.trailingSlash, skipTrailingSlashRedirect: config.skipTrailingSlashRedirect, basePath: config.basePath, assetPrefix: config.assetPrefix, assetBase: publicAssetBase(config) };
   const customRoutes = await compileCustomRoutes(config);
@@ -219,7 +223,7 @@ async function buildProject(projectRoot, { dev = false, envMode, incremental = f
   const refresh = dev ? createRefreshTransform(project.root) : undefined;
   const fonts = createFonts({ projectRoot: project.root, stage, assetBase: publicPaths.assetBase });
   const cssModules = createCssModules({ projectRoot: project.root, stage, assetBase: publicPaths.assetBase, sassOptions: config.sassOptions });
-  configureCompiler({config,root:project.root,stage,buildId,dev,incremental,devInputs,assetBase:publicPaths.assetBase});
+  configureCompiler({config,root:project.root,stage,buildId,dev,incremental,devInputs,tsconfig,assetBase:publicPaths.assetBase});
   try {
     await mkdir(path.join(stage, 'runtime'), { recursive: true });
     await mkdir(path.join(stage, 'compat'), { recursive: true });
@@ -235,6 +239,7 @@ async function buildProject(projectRoot, { dev = false, envMode, incremental = f
     }
     await prepareImageResponse(stage);
     manifest.config.serverActions = config.experimental.serverActions;
+    if (config.workerRetirement) manifest.config.workerRetirement = config.workerRetirement;
     const cacheHandlers = await prepareCacheHandlers({ config, projectRoot: project.root, stage, environment });
     if (Object.keys(cacheHandlers).length) manifest.config.cacheHandlers = cacheHandlers;
     const cacheHandler = await prepareCacheHandler({ config, projectRoot: project.root, stage, environment });
@@ -290,10 +295,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);
@@ -323,6 +333,7 @@ async function buildProject(projectRoot, { dev = false, envMode, incremental = f
         ...(appRoute ? { app: { client: appRoute.client, css: appRoute.css } } : {}),
       }));
     }
+    await writeRuntimeContract(stage);
     await writeFile(path.join(stage, 'manifest.json'), JSON.stringify(manifest, null, 2) + '\n');
     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 });

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) {

package/build/native-packages.mjs

@@ -89,7 +89,11 @@ export function createNativePackages(projectRoot, { isClientSource }) {
             }
             if (args.path.startsWith('.') || args.path.startsWith('#')) return;
             const resolved = await esbuild.resolve(args.path, { importer: args.importer, resolveDir: args.resolveDir, kind: args.kind, pluginData: { prnextNativeResolving: true } });
-            if (resolved.errors.length || resolved.external || resolved.namespace !== 'file') return resolved;
+            // esbuild knows whether the original require() is inside try/catch.
+            // A plugin error would erase that optional-dependency semantics.
+            // Let normal resolution report genuine missing imports itself.
+            if (resolved.errors.length) return;
+            if (resolved.external || resolved.namespace !== 'file') return resolved;
             references.set(resolved.path, { specifier: args.path, importer: args.importer });
             const owner = ownerFor(resolved.path) || await discoverOwner(resolved.path, mode);
             if (owner) {

package/build/npm-packages.mjs

@@ -1,6 +1,6 @@
 import path from 'node:path';
 import { readFile } from 'node:fs/promises';
-import { builtinModules } from 'node:module';
+import { builtinModules, createRequire } from 'node:module';
 import { parse } from '@babel/parser';
 import { VISITOR_KEYS } from '@babel/types';
 import { createNativeDiscovery } from './native-discovery.mjs';
@@ -15,6 +15,7 @@ const bare = name => !name.startsWith('.') && !name.startsWith('#') && !path.isA
 /** Inspect reached imports once per compiler graph; never execute npm modules. */
 export function npmPackagesPlugin({ pages = false, projectRoot, transpilePackages = [], serverExternalPackages = [] }) {
   const transpile = new Set(transpilePackages), external = new Set(serverExternalPackages);
+  const nodeResolve = createRequire(path.join(projectRoot, 'package.json')).resolve;
   const sources = new Map(), decisions = new Map();
   let sourceBytes = 0;
   const native = createNativeDiscovery({ projectRoot, isClientSource: source => /['"]use (?:client|server)['"]/.test(source) });
@@ -90,7 +91,18 @@ export function npmPackagesPlugin({ pages = false, projectRoot, transpilePackage
       // same validation as Pages to avoid bypassing compatibility transforms.
       if (!pages && !external.has(name)) return;
       const resolved = await resolve(args.path, args.importer || path.join(projectRoot, 'package.json'), args.kind);
-      if (resolved.errors.length || resolved.external || resolved.namespace !== 'file') return resolved;
+      if (resolved.errors.length) return;
+      if (resolved.external || resolved.namespace !== 'file') return resolved;
+      // A tsconfig paths/baseUrl import can look like an npm specifier while
+      // resolving to application source. Node cannot resolve that alias from
+      // the emitted server bundle; keep the resolved source in the graph.
+      if (!resolved.path.split(path.sep).includes('node_modules')) {
+        let nodePath;
+        try { nodePath = nodeResolve(args.path, { paths: [path.dirname(args.importer || path.join(projectRoot, 'package.json'))] }); } catch {}
+        // Preserve externalization of real workspace packages that Node can
+        // resolve through a node_modules link, even after esbuild realpaths it.
+        if (nodePath !== resolved.path) return resolved;
+      }
       const decision = await classify(resolved.path);
       const fromRoot = await resolve(args.path, path.join(projectRoot, 'package.json'), args.kind);
       const nestedResolution = fromRoot.errors.length || fromRoot.path !== resolved.path;