@thomas.f/prnext 0.1.0-alpha.1

package/build/cache-handlers.mjs

@@ -0,0 +1,54 @@
+import { build } from 'esbuild';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import {frameworkImportName} from './framework-imports.mjs';
+
+export function validateCacheHandler(input) {
+  if (input === undefined) return undefined;
+  if (typeof input !== 'string' || !input || input.includes('\0') || Buffer.byteLength(input) > 4096) throw new TypeError('cacheHandler must be a module path');
+  return input;
+}
+
+export async function prepareCacheHandler(options) {
+  if (!options.config.cacheHandler) return undefined;
+  const handlers = await prepareCacheHandlers({ ...options, config: { cacheHandlers: { __legacy: options.config.cacheHandler } } });
+  return handlers.__legacy;
+}
+
+export function validateCacheHandlers(input) {
+  if (input === undefined) return {};
+  if (!input || typeof input !== 'object' || Array.isArray(input)) throw new TypeError('cacheHandlers must be an object of module paths');
+  if (Object.keys(input).length > 16) throw new TypeError('cacheHandlers accepts at most 16 handlers');
+  const result = Object.create(null);
+  for (const [name, value] of Object.entries(input)) {
+    if (!/^[a-zA-Z][a-zA-Z0-9_-]{0,63}$/.test(name) || ['private', '__proto__', 'constructor', 'prototype'].includes(name)) throw new TypeError(`Invalid cache handler name: ${name}`);
+    if (value === undefined) continue;
+    if (typeof value !== 'string' || !value || value.includes('\0') || Buffer.byteLength(value) > 4096) throw new TypeError(`cacheHandlers.${name} must be a module path`);
+    result[name] = value;
+  }
+  return result;
+}
+
+/** Private server entries travel with the build; no handler code is sent to browsers. */
+export async function prepareCacheHandlers({ config, projectRoot, stage, environment = {} }) {
+  const result = {};
+  const compiled = new Map();
+  const require = createRequire(path.join(projectRoot, 'package.json'));
+  for (const [name, source] of Object.entries(config.cacheHandlers || {})) {
+    let entry;
+    try { entry = require.resolve(source.startsWith('.') || path.isAbsolute(source) ? path.resolve(projectRoot, source) : source); }
+    catch (error) { throw new Error(`Cannot resolve cacheHandlers.${name}: ${source}`, { cause: error }); }
+    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,
+      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) {
+        builder.onResolve({ filter: /^(?:next|prnext|@thomas\.f\/prnext)\/(cache|headers|server)(?:\.js)?$/ }, ({ path: specifier }) => ({ path: `../compat/${frameworkImportName(specifier)}.cjs`, external: true }));
+      } }],
+    });
+    result[name] = output;
+    compiled.set(entry, output);
+  }
+  return result;
+}

package/build/check.mjs

@@ -0,0 +1,40 @@
+import path from 'node:path';
+import { readFile } from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import { loadProjectConfig } from './config.mjs';
+import { validateCompilerConfig } from './compiler.mjs';
+import { scanProject } from './scan.mjs';
+import { compileCustomRoutes } from './custom-routes.mjs';
+import { validateReactVersions } from './app.mjs';
+import { snapshotEnvConfig } from '../runtime/env.mjs';
+
+/** Preflight an existing project without rewriting sources, dependencies or build output. */
+export async function checkProject(directory, { dev = false, validateDependencies = true } = {}) {
+  const root = path.resolve(directory);
+  const report = { root, ok: false, routes: [], versions: {}, errors: [], notes: [
+    'Preflight validates configuration, route conventions and installed React versions. A successful production build and browser tests are still required.',
+    'Webpack plugin hooks are validated during compilation; preflight only validates plugin shape and translated configuration.',
+    'Rust handles HTTP, routing, static files, images and persistent caches. React and npm JavaScript execute on Node/V8.',
+  ] };
+  const restore = snapshotEnvConfig();
+  try {
+    const config = await loadProjectConfig(root, {dev});
+    if (config.onDemandEntries) report.notes.push('onDemandEntries is accepted for Next plugin compatibility. PRNext compiles all development routes and does not use Next\'s in-memory page eviction queue; these retention settings do not change its memory limits.');
+    await compileCustomRoutes(config);
+    const project = await scanProject(root, {basePath:config.basePath,pageExtensions:config.pageExtensions,i18n:config.i18n});
+    await validateCompilerConfig(config,root,{dev,edge:project.middleware?.runtime==='edge'||project.routes.some(route=>route.cacheConfig?.runtime==='edge'||route.handlerConfig?.runtime==='edge')});
+    report.routes = project.routes.filter(route=>!route.internal).map(({pattern,kind,router})=>({pattern,kind,router:router||'pages'}));
+    const resolve = createRequire(path.join(root,'package.json'));
+    for (const name of ['next','react','react-dom','react-server-dom-webpack']) {
+      try { report.versions[name] = JSON.parse(await readFile(resolve.resolve(`${name}/package.json`),'utf8')).version; }
+      catch { report.versions[name] = null; }
+    }
+    if (validateDependencies) {
+      if (project.routes.some(route=>route.router==='app')) await validateReactVersions(resolve);
+      else if (!report.versions.react || !report.versions['react-dom']) throw new Error('Install react and react-dom in the project before building Pages routes.');
+    } else report.notes.push('Installed React versions have not been validated yet; migration checks them after dependency installation.');
+    report.ok = true;
+  } catch (error) { report.errors.push(error.message); }
+  finally { restore(); }
+  return report;
+}

package/build/compiler.mjs

@@ -0,0 +1,222 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { build as esbuild } from 'esbuild';
+import { runLoaders } from 'loader-runner';
+import fs from 'node:fs';
+import { mkdir, writeFile, readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { moduleResolutionPlugin, validateWebpackResolution } from './module-resolution.mjs';
+import { cachedLoader } from './loader-cache.mjs';
+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';
+
+let validateOptions;
+const compilation = new AsyncLocalStorage();
+export const withCompilation = callback => withSourceMaps(()=>compilation.run({ targets: new Map(), loaded: new Map() }, callback));
+export function configureCompiler(options) { Object.assign(compilation.getStore() || {}, options);configureSourceMaps(options.dev || options.config?.productionBrowserSourceMaps); }
+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)$/;
+function condition(value, input) {
+  if (value === undefined) return true;
+  if (value instanceof RegExp) { value.lastIndex = 0; return value.test(input); }
+  if (typeof value === 'string') return input.startsWith(value);
+  if (typeof value === 'function') return !!value(input);
+  if (Array.isArray(value)) return value.some(item => condition(item, input));
+  if (value && typeof value === 'object' && Object.keys(value).some(key=>!['and','or','not'].includes(key))) throw new Error('Unsupported webpack rule condition field');
+  if (value && typeof value === 'object') return (!value.and || value.and.every(item => condition(item,input))) && (!value.or || value.or.some(item => condition(item,input))) && (!value.not || !condition(value.not,input));
+  throw new Error('Unsupported webpack rule condition');
+}
+function applies(rule,file,issuer,query) { return condition(rule.test,file) && condition(rule.include,file) && !(rule.exclude && condition(rule.exclude,file)) && condition(rule.issuer,issuer) && condition(rule.resourceQuery,query); }
+async function matching(rules, file, issuer = '', query = '', output = [], read = sourceReader(file)) {
+  for (const rule of rules) {
+    if (!applies(rule,file,issuer,query)) continue;
+    if (rule.prnextCondition && !await rule.prnextCondition(file,read)) continue;
+    if (rule.oneOf) { const selected = rule.oneOf.find(item => applies(item,file,issuer,query)); if (selected) await matching([selected],file,issuer,query,output,read); }
+    if (rule.rules) await matching(rule.rules,file,issuer,query,output,read);
+    const use = typeof rule.use === 'function' ? rule.use({resource:file,resourceQuery:query,issuer}) : rule.use ?? (rule.loader ? {loader:rule.loader,options:rule.options} : []);
+    for (const item of Array.isArray(use) ? use : [use]) output.push({ ...(typeof item === 'string' ? {loader:item} : item), enforce:rule.enforce });
+  }
+  return output;
+}
+function validateRules(rules) {
+  if (!Array.isArray(rules) || rules.length > 256) throw new Error('webpack.module.rules must contain at most 256 rules');
+  for (const rule of rules) {
+    if (!rule || typeof rule !== 'object') throw new Error('Invalid webpack rule');
+    for (const key of Object.keys(rule)) if (!['test','include','exclude','issuer','resourceQuery','use','loader','options','oneOf','rules','enforce','type','resolve'].includes(key)) throw new Error(`webpack rule ${key} is not implemented`);
+    // The bridge already parses JavaScript as auto and resolves extensionless
+    // ESM requests. Accept the equivalent rule injected by Contentlayer.
+    if (rule.type !== undefined && rule.type !== 'javascript/auto') throw new Error(`webpack rule type ${rule.type} is not implemented`);
+    if (rule.resolve !== undefined && (!rule.resolve || typeof rule.resolve !== 'object' || Array.isArray(rule.resolve) || Object.keys(rule.resolve).some(key => key !== 'fullySpecified') || rule.resolve.fullySpecified !== false)) throw new Error('webpack rule resolve only supports fullySpecified: false');
+    if (rule.enforce && !['pre','post'].includes(rule.enforce)) throw new Error('Invalid webpack rule enforce');
+    if (rule.rules) validateRules(rule.rules);
+    if (rule.oneOf) validateRules(rule.oneOf);
+  }
+}
+async function targetConfig(state, target) {
+  if (!state.targets.has(target)) state.targets.set(target,(async()=>{
+    const webpack = state.config.webpack ? (await import('webpack')).default : undefined;
+    const base = { mode:state.dev?'development':'production', context:state.root, resolve:{alias:{},extensions:['.tsx','.ts','.jsx','.js','.mjs','.json']},module:{rules:[]},plugins:[] };
+    const configured = state.config.webpack ? await state.config.webpack(base,{buildId:state.buildId,dev:state.dev,isServer:target!=='browser',nextRuntime:target==='browser'?undefined:target==='edge'?'edge':'nodejs',webpack,
+      defaultLoaders:{babel:{loader:new URL('./passthrough-loader.cjs',import.meta.url).pathname}}}) : base;
+    if (!configured || typeof configured !== 'object') throw new Error('webpack hook must return its configuration');
+    for (const key of Object.keys(configured)) if (!['mode','context','resolve','module','plugins','watchOptions'].includes(key)) throw new Error(`webpack.${key} cannot be translated to the PRNext compiler`);
+    const watchOptions = configured.watchOptions;
+    if (watchOptions !== undefined) {
+      if (!watchOptions || typeof watchOptions !== 'object' || Array.isArray(watchOptions) || Object.keys(watchOptions).some(key => key !== 'ignored')) throw new Error('webpack.watchOptions only supports ignored');
+      const ignored = watchOptions.ignored;
+      if (ignored !== undefined && !(ignored instanceof RegExp) && typeof ignored !== 'string' && !(Array.isArray(ignored) && ignored.every(value => typeof value === 'string'))) throw new Error('webpack.watchOptions.ignored must be a string, RegExp or array of strings');
+    }
+    if (configured.mode !== base.mode || configured.context !== state.root) throw new Error('webpack mode/context cannot be changed');
+    for (const key of Object.keys(configured.resolve || {})) if (!['alias','extensions'].includes(key)) throw new Error(`webpack.resolve.${key} is not implemented`);
+    for (const key of Object.keys(configured.module || {})) if (key !== 'rules') throw new Error(`webpack.module.${key} is not implemented`);
+    const rules = state.config.webpack ? configured.module?.rules || [] : turbopackRules(state.config.turbopack?.rules,state,target);
+    if (state.config.webpack) validateRules(rules);
+    const resolution = validateWebpackResolution(configured.resolve);
+    const define = {}, graphPlugins = [], banners = [], footers = [];
+    for (let plugin of configured.plugins || []) {
+      if (plugin instanceof webpack.EnvironmentPlugin) {
+        const values = {};
+        for (const key of plugin.keys) {
+          const value = process.env[key] ?? plugin.defaultValues[key];
+          if (value === undefined) throw new Error(`EnvironmentPlugin: ${key} environment variable is undefined`);
+          values[`process.env.${key}`] = JSON.stringify(value);
+          values[`import.meta.env.${key}`] = JSON.stringify(value);
+        }
+        plugin = new webpack.DefinePlugin(values);
+      }
+      if (plugin instanceof webpack.BannerPlugin) {
+        if (typeof plugin.options.banner !== 'string' || Object.keys(plugin.options).some(key => !['banner','raw','footer'].includes(key))) {graphPlugins.push(plugin);continue;}
+        (plugin.options.footer ? footers : banners).push(plugin.banner({}));
+        continue;
+      }
+      if (!(plugin instanceof webpack.DefinePlugin)) {
+        if (!plugin || typeof plugin.apply !== 'function') throw new Error('Webpack plugins must implement apply(compiler)');
+        graphPlugins.push(plugin); continue;
+      }
+      const validateDefinitions = (values,prefix='') => {for(const [name,value] of Object.entries(values)) {
+        const key=prefix+name;
+        if (/^(?:process\.env\.(?:NODE_ENV|NEXT_RUNTIME|PRNEXT_)|__prnext)/.test(key.replace(/^typeof /,''))) throw new Error(`DefinePlugin cannot override reserved ${key}`);
+        if(value && Object.getPrototypeOf(value)===Object.prototype)validateDefinitions(value,key+'.');
+      }};
+      validateDefinitions(plugin.definitions);
+      if(Object.entries(plugin.definitions).some(([key,value])=>key.startsWith('typeof ') || !['string','number','boolean'].includes(typeof value))) {graphPlugins.push(plugin);continue;}
+      for (const [key,value] of Object.entries(plugin.definitions)) {
+        define[key] = String(value);
+      }
+    }
+    return {rules,resolution,define,graphPlugins,banners,footers,watchOptions,graph:graphPlugins.length>0 || !!state.config.webpack && rules.length>0};
+  })());
+  return state.targets.get(target);
+}
+export async function validateCompilerConfig(config, root, {dev=false,edge=false}={}) {
+  if (!config.webpack) return;
+  const state={config,root,dev,buildId:'prnext-check',targets:new Map()};
+  for (const target of ['node','browser',...(edge?['edge']:[])]) await targetConfig(state,target);
+}
+export async function build(options) {
+  const state = compilation.getStore();
+  // 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.
+  const run=AsyncLocalStorage.snapshot();
+  options={...options,plugins:(options.plugins || []).map(plugin=>({...plugin,setup(builder){
+    return run(()=>{
+      const hooks={};
+      for(const name of ['onResolve','onLoad'])hooks[name]=(settings,callback)=>builder[name](settings,(...args)=>run(callback,...args));
+      for(const name of ['onStart','onEnd','onDispose'])hooks[name]=callback=>builder[name]((...args)=>run(callback,...args));
+      return plugin.setup({...builder,...hooks});
+    });
+  }}))};
+  // Runtime vendor bundles are framework-owned, not project webpack targets.
+  const projectGraph = (options.plugins || []).some(plugin => framework.test(plugin.name));
+  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';
+  const config = await targetConfig(state,target);
+  validateOptions ||= (await import('schema-utils')).validate;
+  const callbacks = [];
+  const require = createRequire(path.join(state.root,'package.json'));
+  const emitted = new Map();
+  const loaderPlugin = {name:'prnext-webpack-loaders',setup(builder) {
+    builder.onResolve({filter:/.*/},async args=>{
+      if (args.pluginData?.prnextLoaderResolution || args.namespace && args.namespace !== 'file') return;
+      if (args.path.includes('!')) throw new Error('Inline loader requests require the webpack backend; configure webpack.module.rules or a graph plugin');
+      const result = await builder.resolve(args.path,{resolveDir:args.resolveDir,importer:args.importer,kind:args.kind,with:args.with,pluginData:{...args.pluginData,prnextLoaderResolution:true}});
+      if (result.errors.length || result.external || !path.isAbsolute(result.path)) return;
+      const loaders = await matching(config.rules,result.path,args.importer,result.suffix || '');
+      if (!loaders.length) return;
+      return {path:result.path,namespace:'file',suffix:result.suffix,pluginData:{prnextLoaders:loaders,issuer:args.importer}};
+    });
+    builder.onLoad({filter:/.*/,namespace:'file'},async args=>{
+      let selected = args.pluginData?.prnextLoaders || await matching(config.rules,args.path,'',args.suffix);
+      if(args.inlinePrefix)selected=selected.filter(item=>args.inlinePrefix==='!'?!!item.enforce:args.inlinePrefix==='-!'?item.enforce==='post':false);
+      if (!selected.length) return;
+      const loaders = selected.sort((a,b)=>({post:0,pre:2}[a.enforce]??1)-({post:0,pre:2}[b.enforce]??1)).map(item=>({loader:require.resolve(item.loader),options:item.options}));
+      const execute = ()=>new Promise((resolve,reject)=>{
+        const assets = [], warnings = [], errors = [];
+        function resolveModule(context,request,callback){
+          if (args.webpackContext) {this.cacheable(false);return args.webpackContext.getResolve()(context,request,callback);}
+          const promise = builder.resolve(request,{resolveDir:context,kind:'import-statement',pluginData:{prnextLoaderResolution:true}}).then(value=>{if(value.errors.length || !value.path)throw new Error(`Cannot resolve ${request} from ${context}`);return value.path;});
+          if (callback) promise.then(value=>callback(null,value),callback); else return promise;
+        }
+        runLoaders({resource:args.path+(args.suffix || ''),loaders,readResource:(file,done)=>args.prnextSource!==undefined && file===args.path ? done(null,Buffer.from(args.prnextSource),args.prnextSourceMap) : fs.readFile(file,done),context:{
+          version:2,rootContext:state.root,mode:state.dev?'development':'production',target:target==='node'?'node':'web',sourceMap:!!options.sourcemap,fs,
+          getOptions(schema){const value=this.query && typeof this.query==='object'?this.query:this.query?Object.fromEntries(new URLSearchParams(this.query.slice(1))):{};if(schema)validateOptions(schema,value,{name:this.loaders[this.loaderIndex].path});return value;},
+          resolve:resolveModule,getResolve(settings){
+            if (!settings || !Object.keys(settings).length) return resolveModule.bind(this);
+            if (!args.webpackContext) throw new Error('Custom getResolve options require a webpack configuration');
+            const resolve=args.webpackContext.getResolve(settings),loader=this;
+            return (context,request,callback)=>{
+              // Native resolution tracks dependencies on the webpack module, not
+              // the disk runner: do not persist an incomplete dependency snapshot.
+              loader.cacheable(false);
+              return resolve(context,request,callback);
+            };
+          },
+          getLogger:()=>console,emitWarning:error=>warnings.push(String(error?.message||error)),emitError:error=>errors.push(error instanceof Error?error:new Error(String(error))),
+          emitFile(name,content){if(typeof name!=='string'||path.isAbsolute(name)||name.split(/[\\/]/).some(part=>part==='..'||!part)||/[\0?#]/.test(name))throw new Error(`Unsafe loader asset path: ${name}`);assets.push({name,data:Buffer.from(content).toString('base64')});},
+          importModule(...values){if(!args.webpackContext)throw new Error('loader importModule requires a webpack configuration');this.cacheable(false);return args.webpackContext.importModule(...values);},
+          loadModule(...values){if(!args.webpackContext)throw new Error('loader loadModule requires a webpack configuration');this.cacheable(false);return args.webpackContext.loadModule(...values);},
+        }},(error,result)=>{
+          if(error||errors.length)return reject(error||errors[0]);
+          if(!result?.result || !['string','object'].includes(typeof result.result[0]))return reject(new Error('Loader must return JavaScript source'));
+          const source=Buffer.isBuffer(result.result[0])?result.result[0].toString():result.result[0];
+          if(typeof source!=='string')return reject(new Error('Loader must return a string or Buffer'));
+          resolve({source,...(options.sourcemap && result.result[1]?{map:typeof result.result[1]==='string'?JSON.parse(result.result[1]):result.result[1]}:{}),assets,warnings,cacheable:result.cacheable,dependencies:result.fileDependencies,contexts:result.contextDependencies,missing:result.missingDependencies});
+        });
+      });
+      // A loader installed by a graph plugin may already have changed the input.
+      // Its source is not represented by the disk-loader cache's fingerprint.
+      const transformed = args.prnextSource!==undefined ? await execute() : await cachedLoader({root:state.root,file:args.path,query:args.suffix || '',loaders,target,dev:state.dev,sourceMap:!!options.sourcemap,mapPipeline:1,resolution:config.resolution,turbopackResolution:{resolveAlias:state.config.turbopack?.resolveAlias,resolveExtensions:state.config.turbopack?.resolveExtensions}},execute);
+      const mappedSource=inlineSourceMap(transformed.source,transformed.map);
+      for(const asset of transformed.assets){const previous=emitted.get(asset.name);if(previous && previous!==asset.data)throw new Error(`Conflicting loader asset: ${asset.name}`);emitted.set(asset.name,asset.data);}
+      state.loaded.set(args.path,{...transformed,source:mappedSource});
+      for (const callback of callbacks) {
+        const result=await callback({...args,prnextSource:mappedSource});
+        if(result)return {...result,loader:result.loader || 'jsx',watchFiles:[...(result.watchFiles||[]),...transformed.dependencies],watchDirs:transformed.contexts,warnings:[...(result.warnings||[]),...transformed.warnings.map(text=>({text}))]};
+      }
+      return {contents:mappedSource,loader:'jsx',resolveDir:path.dirname(args.path),watchFiles:transformed.dependencies,watchDirs:transformed.contexts,warnings:transformed.warnings.map(text=>({text}))};
+    });
+  }};
+  const plugins = (options.plugins || []).map(plugin=>!framework.test(plugin.name)?plugin:{...plugin,setup(builder){
+    return plugin.setup({...builder,onLoad(settings,callback){if(settings.namespace==='file')callbacks.push(callback);builder.onLoad(settings,callback);}});
+  }});
+  if (config.graph) return webpackGraph({...options,
+    ...(config.banners.length ? {banner:{...options.banner,js:[options.banner?.js,...config.banners].filter(Boolean).join('\n')}} : {}),
+    ...(config.footers.length ? {footer:{...options.footer,js:[options.footer?.js,...config.footers].filter(Boolean).join('\n')}} : {}),
+    define:{...options.define,...config.define},plugins:[moduleResolutionPlugin(config.resolution,state.root),loaderPlugin,...plugins],
+  }, {state,config,target}).then(async result=>{
+    for(const [name,data] of emitted){const file=path.join(state.stage,'assets',name);await mkdir(path.dirname(file),{recursive:true});await writeFile(file,Buffer.from(data,'base64'));}
+    return result;
+  });
+  const result = await compile({...options,
+    ...(config.banners.length ? {banner:{...options.banner,js:[options.banner?.js,...config.banners].filter(Boolean).join('\n')}} : {}),
+    ...(config.footers.length ? {footer:{...options.footer,js:[options.footer?.js,...config.footers].filter(Boolean).join('\n')}} : {}),
+    define:{...options.define,...config.define,__webpack_public_path__:JSON.stringify(state.assetBase+'/')},plugins:[moduleResolutionPlugin(config.resolution,state.root),loaderPlugin,...plugins]});
+  for(const [name,data] of emitted){const file=path.join(state.stage,'assets',name);await mkdir(path.dirname(file),{recursive:true});await writeFile(file,Buffer.from(data,'base64'));}
+  return result;
+}

package/build/config.mjs

@@ -0,0 +1,193 @@
+import { build as bundle } from 'esbuild';
+import { readdir, readFile, writeFile, rm } from 'node:fs/promises';
+import { randomUUID } from 'node:crypto';
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { loadEnvConfig } from '../runtime/env.mjs';
+import constants from '../compat/constants.cjs';
+import cacheProfiles from '../compat/cache-life.cjs';
+import { validateDistDir } from '../runtime/build-directory.mjs';
+import { validateCacheHandler, validateCacheHandlers } from './cache-handlers.mjs';
+import { validateImagesConfig } from './images-config.mjs';
+import { pageExtensionPattern, defaultPageExtensions } from './page-extensions.mjs';
+import { validateServerActions } from './server-actions-config.mjs';
+import { validateStandaloneConfig } from './standalone-config.mjs';
+import { validateTurbopack } from './module-resolution.mjs';
+import { validateI18n } from './i18n.mjs';
+import { frameworkPackages } from './framework-imports.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('cacheMaxMemorySize');
+supported.add('turbopack');
+supported.add('i18n');
+supported.add('webpack');
+supported.add('onDemandEntries');
+for (const key of ['output', 'outputFileTracingRoot', 'outputFileTracingIncludes', 'outputFileTracingExcludes']) supported.add(key);
+
+function validPrefixPath(value, where, { root = false } = {}) {
+  if (/[^\x00-\x7f]/.test(value)) throw new Error(`${where} must use an ASCII URL pathname; percent-encode non-ASCII characters explicitly.`);
+  if ((!root && value === '/') || !value.startsWith('/') || value.startsWith('//') || /[\s\\?#\u0000-\u001f\u007f]/.test(value) ||
+      value.replace(/\/+$/, '').split('/').some((segment, index) => index && (!segment || segment === '.' || segment === '..')) || /%(?![\da-f]{2})/i.test(value)) {
+    throw new Error(`${where} must be a URL pathname prefix without query, fragment, whitespace, backslashes, empty interior segments or dot segments.`);
+  }
+}
+
+export function publicAssetBase(config) {
+  return (config.assetPrefix || config.basePath || '').replace(/\/+$/, '') + '/_prnext/assets';
+}
+
+function configPlugin() {
+  return {
+    name: 'prnext-project-config',
+    setup(build) {
+      build.onResolve({ filter: /^(?:next|prnext|@thomas\.f\/prnext)\/constants(?:\.js)?$/ }, () => ({ path: path.join(packageRoot, 'compat/constants.cjs') }));
+      build.onLoad({ filter: /\.(?:[cm]?js|ts)$/ }, async ({ path: filename }) => {
+        if (filename.includes(`${path.sep}node_modules${path.sep}`)) return;
+        // Preserve filesystem paths after bundling config's relative helpers.
+        const prefix = `const __prnext_config_url=${JSON.stringify(pathToFileURL(filename).href)};const __prnext_config_file=${JSON.stringify(filename)};const __prnext_config_dir=${JSON.stringify(path.dirname(filename))};\n`;
+        const source = (await readFile(filename, 'utf8')).replace(/^#![^\n]*(?:\n|$)/, '');
+        return { contents: prefix + source, loader: filename.endsWith('.ts') ? 'ts' : 'js', resolveDir: path.dirname(filename) };
+      });
+    },
+  };
+}
+
+async function importConfig(filename) {
+  const temporary = path.join(path.dirname(filename), `.prnext-config-${randomUUID()}.mjs`);
+  try {
+    const result = await bundle({ entryPoints: [filename], absWorkingDir: path.dirname(filename), bundle: true, write: false, platform: 'node', target: 'node22', format: 'esm', packages: 'external', logLevel: 'silent',
+      define: { 'import.meta.url': '__prnext_config_url', __filename: '__prnext_config_file', __dirname: '__prnext_config_dir' },
+      banner: { js: `import {createRequire as __prnext_create_require} from 'node:module';const require=__prnext_create_require(${JSON.stringify(pathToFileURL(filename).href)});` },
+      plugins: [configPlugin()],
+    });
+    await writeFile(temporary, result.outputFiles[0].contents, { flag: 'wx' });
+    const imported = await import(pathToFileURL(temporary).href);
+    return imported.default;
+  } finally { await rm(temporary, { force: true }); }
+}
+
+export function validateProjectConfig(input, filename = 'project config') {
+  if (!input || typeof input !== 'object' || Array.isArray(input)) throw new Error(`${filename} must export a configuration object or a function returning one.`);
+  for (const key of Object.keys(input)) {
+    if (!supported.has(key)) throw new Error(`${filename}: option "${key}" is not supported by PRNext. It cannot be silently ignored.`);
+  }
+  // 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)) };
+  if (config.onDemandEntries !== undefined) {
+    const entries = config.onDemandEntries;
+    if (!entries || typeof entries !== 'object' || Array.isArray(entries)) throw new TypeError('onDemandEntries must be an object');
+    for (const [key, value] of Object.entries(entries)) {
+      if (!['maxInactiveAge', 'pagesBufferLength'].includes(key)) throw new TypeError(`onDemandEntries.${key} is not supported`);
+      if (value !== undefined && (!Number.isSafeInteger(value) || value < 0)) throw new TypeError(`onDemandEntries.${key} must be a non-negative safe integer`);
+    }
+    config.onDemandEntries = { maxInactiveAge: entries.maxInactiveAge ?? 60000, pagesBufferLength: entries.pagesBufferLength ?? 5 };
+  }
+  if (config.webpack !== undefined && typeof config.webpack !== 'function') throw new TypeError('webpack must be a configuration function');
+  config.turbopack = validateTurbopack(config.turbopack);
+  config.i18n = validateI18n(config.i18n);
+  if (config.i18n && config.output === 'export') throw new Error("i18n and output: 'export' cannot be combined; use explicit locale routes for static exports");
+  validateStandaloneConfig(config);
+  config.distDir = validateDistDir(config.distDir);
+  if (config.output === 'export' && (config.distDir === 'out' || config.distDir.startsWith('out/'))) throw new Error("output: 'export' reserves out/ for exported files; choose a different distDir");
+  pageExtensionPattern(config.pageExtensions);
+  config.pageExtensions = [...new Set(config.pageExtensions || defaultPageExtensions)];
+  if (config.reactStrictMode !== undefined && typeof config.reactStrictMode !== 'boolean') throw new Error(`${filename}: reactStrictMode must be a boolean.`);
+  config.cacheComponents ??= false;
+  if (typeof config.cacheComponents !== 'boolean') throw new TypeError('cacheComponents must be a boolean');
+  config.cacheLife = cacheProfiles.profiles(config.cacheLife);
+  for (const key of ['transpilePackages', 'serverExternalPackages']) {
+    const names = config[key] ?? [];
+    if (!Array.isArray(names) || names.some(name => typeof name !== 'string' || !/^(?:@[a-zA-Z0-9_.-]+\/)?[a-zA-Z0-9_.-]+$/.test(name) || name.startsWith('.') || frameworkPackages.includes(name) || /^(?:react|react-dom|react-server-dom-webpack)$/.test(name))) throw new Error(`${filename}: ${key} must be an array of npm package names excluding framework and React packages.`);
+    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.`);
+  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.`);
+  }
+  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) };
+  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.`);
+  }
+  if (config.basePath) {
+    validPrefixPath(config.basePath, `${filename}: basePath`);
+    if (config.basePath.endsWith('/')) throw new Error(`${filename}: basePath must not end with /.`);
+  }
+  if (config.assetPrefix) {
+    if (/^https?:\/\//i.test(config.assetPrefix)) {
+      let url;
+      try { url = new URL(config.assetPrefix); } catch { throw new Error(`${filename}: assetPrefix must be a valid HTTP(S) URL or pathname prefix.`); }
+      if (url.username || url.password || /[\s\\?#]/.test(config.assetPrefix)) throw new Error(`${filename}: assetPrefix cannot contain credentials, query, fragment, whitespace or backslashes.`);
+      const rawPathname = /^https?:\/\/[^/]*(\/.*)?$/i.exec(config.assetPrefix)?.[1] || '/';
+      validPrefixPath(rawPathname, `${filename}: assetPrefix pathname`, { root: true });
+      config.assetPrefix = url.href.replace(/\/+$/, '');
+    } else {
+      if (/^[A-Za-z][A-Za-z\d+.-]*:/.test(config.assetPrefix)) throw new Error(`${filename}: assetPrefix only supports HTTP(S) URLs and pathname prefixes.`);
+      const prefix = config.assetPrefix.startsWith('/') ? config.assetPrefix : '/' + config.assetPrefix;
+      validPrefixPath(prefix, `${filename}: assetPrefix`, { root: true });
+      // An explicit / selects root assets even when basePath is configured.
+      config.assetPrefix = prefix.replace(/\/+$/, '') || '/';
+    }
+  }
+  for (const key of ['compress', 'poweredByHeader', 'productionBrowserSourceMaps', 'trailingSlash', 'skipTrailingSlashRedirect', 'skipMiddlewareUrlNormalize']) {
+    if (typeof config[key] !== 'boolean') throw new Error(`${filename}: ${key} must be a boolean.`);
+  }
+  for (const key of ['redirects', 'headers', 'rewrites', 'generateBuildId']) {
+    if (config[key] !== undefined && typeof config[key] !== 'function') throw new Error(`${filename}: ${key} must be a function.`);
+  }
+  if (!config.env || typeof config.env !== 'object' || Array.isArray(config.env)) throw new Error(`${filename}: env must be an object of string values.`);
+  const environment = Object.create(null);
+  for (const [key, value] of Object.entries(config.env)) {
+    if (!/^[A-Za-z_$][\w$]*$/.test(key) || /^(?:NODE_|__)/i.test(key) || key === 'NEXT_RUNTIME' || key.startsWith('PRNEXT_')) throw new Error(`${filename}: env key "${key}" is reserved or not a JavaScript identifier.`);
+    if (value === undefined) continue;
+    if (typeof value !== 'string') throw new Error(`${filename}: env.${key} must be a string or undefined.`);
+    environment[key] = value;
+  }
+  config.env = environment;
+  if (config.skipProxyUrlNormalize !== undefined) {
+    if (typeof config.skipProxyUrlNormalize !== 'boolean') throw new TypeError('skipProxyUrlNormalize must be a boolean');
+    config.skipMiddlewareUrlNormalize = config.skipProxyUrlNormalize;
+  }
+  config.cacheHandlers = validateCacheHandlers(config.cacheHandlers);
+  config.cacheHandler = validateCacheHandler(config.cacheHandler);
+  if (config.cacheMaxMemorySize !== undefined && (!Number.isSafeInteger(config.cacheMaxMemorySize) || config.cacheMaxMemorySize < 0 || config.cacheMaxMemorySize > 1024 * 1024 * 1024)) throw new TypeError('cacheMaxMemorySize must be an integer between 0 and 1 GiB');
+  config.images = validateImagesConfig(config.images, { basePath: config.basePath, assetPrefix: config.assetPrefix, trailingSlash: config.trailingSlash });
+  return config;
+}
+
+/** Config and its relative imports are evaluated fresh on every build. */
+export async function loadProjectConfig(projectRoot, { dev = false, envMode, phase = dev ? constants.PHASE_DEVELOPMENT_SERVER : constants.PHASE_PRODUCTION_BUILD } = {}) {
+  const root = path.resolve(projectRoot);
+  loadEnvConfig(root, { dev, mode: envMode });
+  const files = await readdir(root);
+  const names = files.filter(name => configName.test(name));
+  const unsupportedFiles = files.filter(name => /^(?:next|prnext)\.config\.(?:mts|cts|jsx|tsx|json)$/.test(name));
+  if (unsupportedFiles.length) throw new Error(`Unsupported configuration file ${unsupportedFiles.join(', ')}. Use .js, .mjs, .cjs or .ts.`);
+  if (names.length > 1) throw new Error(`Multiple configuration files found: ${names.sort().join(', ')}. Keep one next.config.* or prnext.config.* file.`);
+  if (!names.length) return validateProjectConfig({});
+  const filename = path.join(root, names[0]);
+  let input = await importConfig(filename);
+  if (typeof input === 'function') input = await input(phase, { defaultConfig: { ...defaults, env: {}, experimental: { ...defaults.experimental } } });
+  return validateProjectConfig(input, names[0]);
+}
+
+export function defineEnvironment(config, env = process.env) {
+  const publicValues = Object.fromEntries(Object.entries(env).filter(([key, value]) => key.startsWith('NEXT_PUBLIC_') && value !== undefined));
+  const values = { ...publicValues, ...config.env };
+  return Object.fromEntries(Object.entries(values).map(([key, value]) => [`process.env.${key}`, JSON.stringify(value)]));
+}
+
+export async function generateBuildId(config, { dev = false } = {}) {
+  const generated = !dev && config.generateBuildId ? await config.generateBuildId() : null;
+  if (generated === null) return randomUUID();
+  if (typeof generated !== 'string' || !/^[A-Za-z0-9_-]{1,128}$/.test(generated)) throw new Error('generateBuildId must return null or a nonempty URL-safe string of at most 128 characters (letters, digits, _ or -).');
+  return generated;
+}