@thomas.f/prnext 0.1.17-alpha → 0.1.19-alpha

package/build/compilation-cache.mjs

@@ -0,0 +1,269 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { lstat, readFile, opendir, realpath, readlink, mkdir, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { version as esbuildVersion } from 'esbuild';
+import { buildCacheIdentity, cacheHash, privateCacheDirectory, readCacheRecord, writeCacheRecord } from './persistent-cache.mjs';
+import {mapConcurrent} from './concurrent.mjs';
+import { readCompilationRecord, writeCompilationRecord } from './compilation-store.mjs';
+
+// Graph outputs have a narrower contract than source transforms. In particular,
+// application graph callbacks discover actions, boundaries and font assets. They
+// must run on every generation and are never skipped by this cache.
+const reports = new AsyncLocalStorage();
+const MAX_FILES = 4096, MAX_DIRECTORIES = 8192, MAX_NAMES = 32768;
+const MAX_FILE_BYTES = 16 * 1024 * 1024, MAX_BYTES = 48 * 1024 * 1024;
+const RECORD_LIMIT = 64 * 1024 * 1024;
+const SHA = /^[a-f0-9]{64}$/;
+const frameworkDirectory=name=>['.git','.prnext-cache','.prnext','.prnext-incremental-stage'].includes(name)||/^\.prnext-(?:build|backup|config|postcss)-/.test(name);
+const frameworkPointer=name=>/^\.prnext-output(?:\.json|-.+\.tmp)$/.test(name);
+const ignored = entry => entry.isDirectory() && (entry.name==='node_modules'||frameworkDirectory(entry.name)) || frameworkPointer(entry.name);
+const safePath = file => typeof file === 'string' && file.length < 32768 && path.isAbsolute(file) && !file.includes('\0');
+const inside = (root, file) => { const relative = path.relative(root, file); return relative === '' || !path.isAbsolute(relative) && relative !== '..' && !relative.startsWith('..' + path.sep); };
+export const withCompilationGraphCacheReporting = run => reports.run({ kinds: new Map(), identities:new Map(), listings:new Map(),listingNames:0 }, run);
+export function compilationGraphCacheReport() {
+  const kinds = [...(reports.getStore()?.kinds || [])].map(([kind, value]) => ({ kind, ...value, reasons: { ...value.reasons } }));
+  return { version: 1, scope: 'eligible-production-compilation-graphs', kinds,
+    hits: kinds.reduce((sum, item) => sum + item.hits, 0), misses: kinds.reduce((sum, item) => sum + item.misses, 0),
+    bypasses: kinds.reduce((sum, item) => sum + item.bypasses, 0), reusedBytes: kinds.reduce((sum, item) => sum + item.reusedBytes, 0) };
+}
+function record(kind, outcome, reason, bytes = 0) {
+  const state = reports.getStore(); if (!state) return;
+  if (!state.kinds.has(kind)) state.kinds.set(kind, { hits: 0, misses: 0, bypasses: 0, writes: 0, reusedBytes: 0, reasons: {} });
+  const item = state.kinds.get(kind); item[outcome]++; item.reusedBytes += bytes;
+  if (reason) item.reasons[reason] = (item.reasons[reason] || 0) + 1;
+}
+function serializable(value) {
+  if (value === null || ['string', 'number', 'boolean'].includes(typeof value)) return true;
+  if (Array.isArray(value)) return value.every(serializable);
+  return value && Object.getPrototypeOf(value) === Object.prototype && Object.values(value).every(item => item === undefined || serializable(item));
+}
+const directorySignature=info=>[info.dev,info.ino,info.mode,info.mtimeNs,info.ctimeNs].join(':');
+async function directoryEntries(directory,budget){
+  const state=reports.getStore(),before=await lstat(directory,{bigint:true});
+  if(!before.isDirectory()||before.isSymbolicLink())throw Error('unstable-resolution');
+  const signature=directorySignature(before),saved=state?.listings.get(directory);
+  if(saved?.signature===signature){
+    const after=await lstat(directory,{bigint:true});
+    if(directorySignature(after)===signature){budget.names+=saved.entries.length;if(budget.names>MAX_NAMES)throw Error('resolution-limit');return {entries:saved.entries,info:after,stable:true};}
+  }
+  const entries=[];
+  for await(const entry of await opendir(directory)){if(++budget.names>MAX_NAMES)throw Error('resolution-limit');entries.push(entry);}
+  const after=await lstat(directory,{bigint:true}),stable=signature===directorySignature(after);
+  if(state&&stable){
+    if(state.listings.has(directory)){state.listingNames-=state.listings.get(directory).entries.length;state.listings.delete(directory);}
+    while(state.listings.size&&(state.listings.size>=MAX_DIRECTORIES||state.listingNames+entries.length>MAX_NAMES)){
+      const [oldest,value]=state.listings.entries().next().value;state.listings.delete(oldest);state.listingNames-=value.entries.length;
+    }
+    if(entries.length<=MAX_NAMES){state.listings.set(directory,{signature,entries});state.listingNames+=entries.length;}
+  }
+  return {entries,info:after,stable};
+}
+async function fileDigest(file, started = Infinity, budget = {bytes:0}) {
+  const before = await lstat(file);
+  if (!before.isFile() || before.isSymbolicLink() || before.size > MAX_FILE_BYTES || before.mtimeMs > started || before.ctimeMs > started) throw Error('unstable-input');
+  budget.bytes+=before.size;if(budget.bytes>MAX_BYTES)throw Error('dependency-limit');
+  const bytes = await readFile(file), after = await lstat(file);
+  if (bytes.length !== before.size || before.size !== after.size || before.mtimeMs !== after.mtimeMs || before.ctimeMs !== after.ctimeMs) throw Error('unstable-input');
+  return cacheHash(bytes);
+}
+async function directoryDigest(directory, budget, started = Infinity, lookup = false, excluded = []) {
+  let listing;
+  try{listing=await directoryEntries(directory,budget);}catch(error){if(error.code==='ENOENT')return 'missing';throw error;}
+  const {info}=listing;
+  if(started!==Infinity&&(Number(info.mtimeNs)/1e6>started||Number(info.ctimeNs)/1e6>started))throw Error('unstable-resolution');
+  const namesAt=async listing=>{
+    const entries=listing.entries.filter(entry=>lookup?['package.json','tsconfig.json','jsconfig.json','.browserslistrc','browserslist','node_modules'].includes(entry.name):!ignored(entry)&&!excluded.includes(path.join(directory,entry.name)));
+    entries.sort((a,b)=>a.name.localeCompare(b.name));
+    return mapConcurrent(entries,async entry=>[entry.name,entry.isDirectory()?'directory':entry.isSymbolicLink()?['link',await readlink(path.join(directory,entry.name))]:entry.isFile()?'file':'other']);
+  };
+  const names=await namesAt(listing),digest=cacheHash(JSON.stringify(names));
+  if(!listing.stable&&cacheHash(JSON.stringify(await namesAt(await directoryEntries(directory,budget))))!==digest)throw Error('unstable-resolution');
+  return digest;
+}
+async function snapshot(root, dependencies, { started = Infinity, imports = [], rejectTsconfig = false, styleTargets=false, baseline, excluded = [] } = {}) {
+  if (!Array.isArray(dependencies) || dependencies.length > MAX_FILES || dependencies.some(file => !safePath(file))) throw Error('dependency-limit');
+  const files = new Set(dependencies), directories = new Set(), trees = new Set([root]), fullDirectories = new Set();
+  if(dependencies.some(file=>path.dirname(file).split(path.sep).some(frameworkDirectory)||frameworkPointer(path.basename(file))||excluded.some(directory=>inside(directory,file))))throw Error('generated-input');
+  for(const name of ['package.json','package-lock.json','npm-shrinkwrap.json','pnpm-lock.yaml','yarn.lock','bun.lock','bun.lockb','.env','.env.local','.env.production','.env.production.local','.env.development','.env.development.local','.env.test','.env.test.local']){
+    const file=path.join(root,name);try{const info=await lstat(file);if(!info.isFile()||info.isSymbolicLink())throw Error('unsafe-config');files.add(file);}catch(error){if(error.code!=='ENOENT')throw error;}
+  }
+  const addParents = async file => {
+    let directory = path.dirname(file);
+    while (true) {
+      directories.add(directory);
+      // Node's package search includes missing nearer node_modules directories.
+      directories.add(path.join(directory, 'node_modules'));
+      for (const name of ['package.json', 'tsconfig.json', 'jsconfig.json', ...(styleTargets?['.browserslistrc','browserslist']:[])]) {
+        const candidate = path.join(directory, name);
+        try {
+          const info = await lstat(candidate);
+          if(name==='browserslist'&&info.isDirectory())continue;
+          if (rejectTsconfig && /^(?:ts|js)config\.json$/.test(name)) throw Error('untracked-tsconfig');
+          if (!info.isFile() || info.isSymbolicLink() || info.size>MAX_FILE_BYTES) throw Error('unsafe-config');
+          if(styleTargets&&(name==='.browserslistrc'||name==='browserslist'||name==='package.json')){
+            const source=await readFile(candidate,'utf8');
+            const targets=name==='package.json'?JSON.stringify(JSON.parse(source).browserslist):source;
+            if(typeof targets==='string'&&/\b(?:extends|stats)\b/i.test(targets))throw Error('custom-browser-targets');
+          }
+          files.add(candidate);
+        } catch (error) { if (error.code !== 'ENOENT') throw error; }
+      }
+      const parent = path.dirname(directory); if (parent === directory) break; directory = parent;
+    }
+  };
+  for (const file of dependencies) {
+    await addParents(file);
+    // Package export/browser maps may choose an absent file anywhere inside the
+    // package. Directory names, including absence, participate in invalidation.
+    let directory = path.dirname(file);
+    while (true) {
+      try { if ((await lstat(path.join(directory, 'package.json'))).isFile()) { trees.add(directory); break; } }
+      catch (error) { if (error.code !== 'ENOENT') throw error; }
+      const parent = path.dirname(directory); if (parent === directory) break; directory = parent;
+    }
+  }
+  for (const [importer, specifier] of imports) {
+    if (typeof specifier !== 'string' || /^(?:node:|[./\\]|[A-Za-z]:)/.test(specifier)) continue;
+    const parts = specifier.split('/'), name = parts.slice(0, specifier.startsWith('@') ? 2 : 1).join('/');
+    if (!name || name.includes('\0') || name.split('/').some(part => part === '..')) throw Error('unsafe-resolution');
+    let directory = path.dirname(importer);
+    while (true) {
+      const candidate = path.join(directory, 'node_modules', name);
+      try { const info = await lstat(candidate); if (info.isSymbolicLink()) throw Error('linked-package'); if (info.isDirectory()) trees.add(candidate); }
+      catch (error) { if (error.code !== 'ENOENT') throw error; }
+      const parent = path.dirname(directory); if (parent === directory) break; directory = parent;
+    }
+  }
+  const walked={names:0};
+  const walk = async (directory, depth = 0) => {
+    if (depth > 32 || directories.size > MAX_DIRECTORIES) throw Error('resolution-limit');
+    const listing=await directoryEntries(directory,walked);
+    directories.add(directory); fullDirectories.add(directory);
+    for (const entry of listing.entries) {
+      if (ignored(entry) || excluded.includes(path.join(directory,entry.name))) continue;
+      if (entry.isSymbolicLink()) throw Error('linked-input');
+      if (entry.isDirectory()) await walk(path.join(directory, entry.name), depth + 1);
+    }
+  };
+  for (const tree of trees) await walk(tree);
+  if (files.size > MAX_FILES || directories.size > MAX_DIRECTORIES) throw Error('dependency-limit');
+  const budget = { names: 0,bytes:0 };
+  const knownFiles = new Map(baseline?.files || []), knownDirectories = new Map((baseline?.directories || []).map(item => [item[0], item]));
+  const result = { excluded, files: await mapConcurrent([...files].sort(),async file => [file, await fileDigest(file, knownFiles.has(file) ? Infinity : started,budget)]),
+    directories: await mapConcurrent([...directories].sort(),async directory => {
+      const lookup = !fullDirectories.has(directory) && path.basename(directory) !== 'node_modules';
+      const known = knownDirectories.get(directory), comparable = known && known[2] === lookup;
+      return [directory, await directoryDigest(directory, budget, comparable ? Infinity : started, lookup, excluded), lookup];
+    }) };
+  for (const [file,digest] of result.files) if (knownFiles.has(file) && knownFiles.get(file) !== digest) throw Error('unstable-input');
+  for (const [directory,digest,lookup] of result.directories) {
+    const known = knownDirectories.get(directory);
+    if (known && known[2] === lookup && known[1] !== digest) throw Error('unstable-resolution');
+  }
+  return result;
+}
+async function validSnapshot(value) {
+  const pairs = (list, missing) => Array.isArray(list) && list.length <= (missing ? MAX_DIRECTORIES : MAX_FILES)
+    && new Set(list.map(item => item?.[0])).size === list.length
+    && list.every(item => Array.isArray(item) && item.length === (missing ? 3 : 2) && safePath(item[0]) && (SHA.test(item[1]) || missing && item[1] === 'missing') && (!missing || typeof item[2] === 'boolean'));
+  if (!value || !Array.isArray(value.excluded) || value.excluded.length>32 || !value.excluded.every(safePath) || !pairs(value.files, false) || !pairs(value.directories, true)) return false;
+  const budget = { names: 0,bytes:0 };
+  for (const [file, digest] of value.files) if (await fileDigest(file,Infinity,budget) !== digest) return false;
+  for (const [directory, digest, lookup] of value.directories) if (await directoryDigest(directory, budget, Infinity, lookup, value.excluded) !== digest) return false;
+  return true;
+}
+/** Framework-owned graph producers explicitly return dependencies and payloads. */
+export async function cachedCompilation({ root, kind, settings, inputs = [], excluded = [], enabled = true, reason, validate, produce, bytes = () => 0, rejectTsconfig = false,styleTargets=false, binary = false }) {
+  if (!enabled || process.env.PRNEXT_BUILD_CACHE === '0' || !serializable(settings)) {
+    record(kind, 'bypasses', process.env.PRNEXT_BUILD_CACHE === '0' ? 'disabled' : reason || 'unsupported-configuration'); return (await produce()).value;
+  }
+  let directory, key;
+  try {
+    root = await realpath(root); directory = await privateCacheDirectory(root, binary ? 'compilation-graphs-v2' : 'compilation-graphs-v1');
+    if(!directory)throw Error('unavailable');
+    // Only metadata for the same current environment is shared. Individual
+    // graph snapshots still re-hash source/config bytes and validate listings.
+    const state=reports.getStore(),environment=cacheHash(JSON.stringify(Object.entries(process.env).sort())),identityKey=root+'\0'+environment;
+    if(state&&!state.identities.has(identityKey)){
+      if(state.identities.size>=8)state.identities.delete(state.identities.keys().next().value);
+      state.identities.set(identityKey,buildCacheIdentity(root));
+    }
+    const identity = directory && await (state?.identities.get(identityKey)||buildCacheIdentity(root));
+    if (!identity) throw Error('unavailable');
+    if(excluded.length>32||!excluded.every(file=>safePath(file)&&inside(root,file)&&file!==root))throw Error('unsafe-output-directory');
+    key = cacheHash(JSON.stringify([identity, esbuildVersion, kind, settings, excluded]));
+    const cached = binary ? await readCompilationRecord(directory, key) : await readCacheRecord(directory, key, RECORD_LIMIT);
+    if (cached?.format === 1 && validate(cached.value) && await validSnapshot(cached.snapshot)) {
+      record(kind, 'hits', undefined, bytes(cached.value)); return cached.value;
+    }
+  } catch { /* Corrupt, excessive or unavailable caches are optional. */ }
+  record(kind, 'misses');
+  let baseline, baselineError;
+  if(directory && key)try{baseline=await snapshot(root,inputs,{rejectTsconfig,excluded,styleTargets});}catch(error){baselineError=error;}
+  const started = Date.now(), produced = await produce();
+  if (directory && key && validate(produced.value)) try {
+    if(!baseline)throw baselineError || Error('snapshot-unavailable');
+    const current = await snapshot(root, produced.dependencies, { started, imports: produced.imports, rejectTsconfig,styleTargets, baseline, excluded });
+    const saved = { format: 1, snapshot: current, value: produced.value };
+    if (await (binary ? writeCompilationRecord(directory, key, saved) : writeCacheRecord(directory, key, saved, RECORD_LIMIT,{maxFiles:1024}))) record(kind, 'writes');
+  } catch (error) { record(kind, 'bypasses', ['unstable-input', 'unstable-resolution', 'untracked-tsconfig', 'linked-package', 'linked-input', 'resolution-limit', 'dependency-limit','generated-input','custom-browser-targets'].includes(error.message) ? error.message : 'snapshot-unavailable'); }
+  else if(!validate(produced.value))record(kind,'bypasses','generation-specific-output');
+  return produced.value;
+}
+
+function validMetafile(value){
+  const object=value=>value&&typeof value==='object'&&!Array.isArray(value),text=value=>typeof value==='string'&&value.length<32768&&!value.includes('\0');
+  const count=value=>Number.isSafeInteger(value)&&value>=0;
+  const imports=value=>Array.isArray(value)&&value.length<=MAX_FILES&&value.every(item=>object(item)&&text(item.path)&&text(item.kind)&&(item.external===undefined||typeof item.external==='boolean'));
+  return object(value)&&object(value.inputs)&&object(value.outputs)&&Object.keys(value.inputs).length<=MAX_FILES&&Object.keys(value.outputs).length<=MAX_FILES
+    &&Object.entries(value.inputs).every(([file,input])=>text(file)&&object(input)&&count(input.bytes)&&imports(input.imports))
+    &&Object.entries(value.outputs).every(([file,output])=>text(file)&&object(output)&&count(output.bytes)&&imports(output.imports)
+      &&(output.entryPoint===undefined||text(output.entryPoint))&&(output.cssBundle===undefined||text(output.cssBundle))
+      &&Array.isArray(output.exports)&&output.exports.length<=MAX_FILES&&output.exports.every(text)&&object(output.inputs)
+      &&Object.keys(output.inputs).length<=MAX_FILES&&Object.entries(output.inputs).every(([file,input])=>text(file)&&object(input)&&count(input.bytesInOutput)));
+}
+function validGraph(value) {
+  return value && Array.isArray(value.files) && value.files.length > 0 && value.files.length <= MAX_FILES
+    && value.files.every(file => Array.isArray(file) && file.length === 3 && typeof file[0] === 'string' && !path.isAbsolute(file[0])
+      && !/[\0<>:"|?*]/.test(file[0]) && file[0].split(/[\\/]/).every(part => part && part !== '.' && part !== '..') && file[1] instanceof Uint8Array && file[1].byteLength <= MAX_FILE_BYTES && typeof file[2] === 'string')
+    && new Set(value.files.map(file => file[0])).size === value.files.length
+    && value.files.reduce((sum, file) => sum + file[1].byteLength, 0) <= MAX_BYTES
+    && validMetafile(value.metafile);
+}
+const deepMap = (value, convert) => typeof value === 'string' ? convert(value) : Array.isArray(value) ? value.map(item => deepMap(item, convert))
+  : value && typeof value === 'object' ? Object.fromEntries(Object.entries(value).map(([key, item]) => [convert(key), deepMap(item, convert)])) : value;
+/** Cache native esbuild graphs only; plugins and generated entries need replay. */
+export async function cachedGraphBuild(options, { root, stage, dev = false, config = {} }, compile) {
+  const output = options.outdir || options.outfile && path.dirname(options.outfile);
+  const permitted = !dev && !(options.plugins?.length) && options.bundle === true && output && stage && inside(stage, path.resolve(output))
+    && !options.stdin && !options.tsconfig && !options.tsconfigRaw && options.mangleCache===undefined && !config.webpack && !Object.keys(config.turbopack?.rules || {}).length;
+  if (!permitted) { record('javascript', 'bypasses', dev ? 'development' : options.plugins?.length ? 'graph-side-effects' : 'unsupported-configuration'); return compile(options); }
+  const token = '__PRNEXT_COMPILATION_STAGE__', toSaved = value => value.replaceAll(stage,()=>token).replaceAll(path.basename(stage),()=>token), fromSaved = value => value.replaceAll(token,()=>stage);
+  const rawSignature = { ...options, plugins: undefined, write: false, metafile: true };
+  if(!serializable(rawSignature)){record('javascript','bypasses','unsupported-configuration');return compile(options);}
+  const signature = deepMap(rawSignature, toSaved);
+  if (!serializable(signature)) { record('javascript', 'bypasses', 'unsupported-configuration'); return compile(options); }
+  let fresh;
+  const entries = Array.isArray(options.entryPoints) ? options.entryPoints.map(entry=>typeof entry==='string'?entry:entry.in) : Object.values(options.entryPoints || {});
+  const excluded = [path.resolve(root,config.distDir || '.prnext'),...(config.output==='export'?[path.join(root,'out')]:[])];
+  const saved = await cachedCompilation({ root, kind: 'javascript', settings: signature, inputs:entries.map(file=>path.resolve(options.absWorkingDir || process.cwd(),file)), excluded, validate: validGraph, rejectTsconfig: true, binary: true,
+    bytes: value => value.files.reduce((sum, file) => sum + file[1].byteLength, 0),
+    produce: async () => {
+      fresh = await compile({ ...options, write: false, metafile: true });
+      // Warnings may carry plugin details/locations; do not replay approximate diagnostics.
+      if (fresh.warnings?.length) return { value: null, dependencies: [] };
+      if(JSON.stringify(fresh.metafile).includes(token))return {value:null,dependencies:[]};
+      const dependencies = Object.keys(fresh.metafile.inputs).map(file => path.resolve(options.absWorkingDir || process.cwd(), file));
+      if (dependencies.some(file => inside(stage, file))) return { value: null, dependencies: [] };
+      const files = fresh.outputFiles.map(file => [path.relative(output, file.path), file.contents, file.hash]);
+      if (fresh.outputFiles.some(file => Buffer.from(file.contents).includes(Buffer.from(stage)) || Buffer.from(file.contents).includes(Buffer.from(path.basename(stage))))) return { value: null, dependencies: [] };
+      const imports = Object.entries(fresh.metafile.inputs).flatMap(([file, input]) => input.imports.filter(item => item.external).map(item => [path.resolve(options.absWorkingDir || process.cwd(), file), item.path]));
+      return { value: { files, metafile: deepMap(fresh.metafile, toSaved) }, dependencies, imports };
+    } });
+  const outputFiles = saved ? saved.files.map(([name, data, hash]) => ({ path: path.join(output, name), contents: Buffer.from(data.buffer, data.byteOffset, data.byteLength), hash, get text() { return this.contents.toString(); } })) : fresh.outputFiles;
+  if (options.write !== false) for (const file of outputFiles) { await mkdir(path.dirname(file.path), { recursive: true }); await writeFile(file.path, file.contents); }
+  return { ...(fresh || { errors: [], warnings: [] }), ...(options.metafile ? { metafile: saved ? deepMap(saved.metafile, fromSaved) : fresh.metafile } : { metafile: undefined }),
+    outputFiles: options.write === false ? outputFiles : undefined };
+}
+
+export const compilationCacheLimits = Object.freeze({ files: MAX_FILES, directories: MAX_DIRECTORIES, names: MAX_NAMES, fileBytes: MAX_FILE_BYTES, bytes: MAX_BYTES });

package/build/compilation-store.mjs

@@ -0,0 +1,142 @@
+// Optional content-addressed compilation outputs. Records contain metadata and
+// references only; binary output bytes are shared across compilation graphs.
+import { constants } from 'node:fs';
+import { open, lstat, rename, unlink, readdir } from 'node:fs/promises';
+import { randomUUID } from 'node:crypto';
+import { serialize, deserialize } from 'node:v8';
+import { deflateRaw, inflateRaw } from 'node:zlib';
+import { promisify } from 'node:util';
+import path from 'node:path';
+import { cacheHash } from './persistent-cache.mjs';
+
+const compress = promisify(deflateRaw), decompress = promisify(inflateRaw);
+const MAGIC = Buffer.from('PRNG2\0');
+const HEADER = MAGIC.length + 1 + 4 + 32;
+const MAX_BLOB = 16 * 1024 * 1024, MAX_RECORD = 16 * 1024 * 1024;
+const MAX_DISK = 64 * 1024 * 1024, MAX_SCAN = 8192, MAX_RECORDS = 1024;
+const digest = /^[a-f0-9]{64}$/;
+const namePattern = /^([a-f0-9]{64})\.(graph|blob)$/;
+
+async function encode(bytes) {
+  let payload = bytes, codec = 0;
+  if (bytes.length >= 16384) {
+    const packed = await compress(bytes, { level: 1 });
+    if (packed.length < bytes.length * 0.9) { payload = packed; codec = 1; }
+  }
+  const header = Buffer.alloc(HEADER);
+  MAGIC.copy(header); header[MAGIC.length] = codec;
+  header.writeUInt32BE(bytes.length, MAGIC.length + 1);
+  Buffer.from(cacheHash(bytes), 'hex').copy(header, MAGIC.length + 5);
+  return [header, payload];
+}
+
+async function read(directory, name, limit) {
+  let file;
+  try {
+    const filename = path.join(directory, name), info = await lstat(filename);
+    if (!info.isFile() || info.isSymbolicLink() || info.size > limit + HEADER || info.size < HEADER) return null;
+    file = await open(filename, constants.O_RDONLY | (constants.O_NOFOLLOW || 0));
+    const stat = await file.stat();
+    if (!stat.isFile() || stat.size > limit + HEADER) return null;
+    const packed = await file.readFile();
+    if (!packed.subarray(0, MAGIC.length).equals(MAGIC)) return null;
+    const size = packed.readUInt32BE(MAGIC.length + 1), codec = packed[MAGIC.length];
+    if (size > limit || codec > 1) return null;
+    const payload = packed.subarray(HEADER);
+    const bytes = codec ? await decompress(payload, { maxOutputLength: Math.max(1, size) }) : payload;
+    if (bytes.length !== size || cacheHash(bytes) !== packed.subarray(MAGIC.length + 5, HEADER).toString('hex')) return null;
+    return bytes;
+  } catch { return null; } finally { await file?.close().catch(() => {}); }
+}
+
+async function write(directory, name, bytes) {
+  const filename = path.join(directory, name), temporary = filename + '.' + randomUUID() + '.tmp';
+  try {
+    const parts = await encode(bytes), file = await open(temporary, 'wx', 0o600);
+    try { for (const part of parts) await file.writeFile(part); } finally { await file.close(); }
+    await rename(temporary, filename);
+  } finally { await unlink(temporary).catch(() => {}); }
+}
+
+function references(record) {
+  const files = record?.value?.files;
+  if (record?.format !== 2 || !Array.isArray(files) || files.length > 4096) return null;
+  if (!files.every(file => Array.isArray(file) && file.length === 4 && typeof file[0] === 'string' && digest.test(file[1]) && typeof file[2] === 'string' && Number.isInteger(file[3]) && file[3] >= 0 && file[3] <= MAX_BLOB)) return null;
+  if (files.reduce((sum, file) => sum + file[3], 0) > 48 * 1024 * 1024) return null;
+  return files;
+}
+
+export async function readCompilationRecord(directory, key) {
+  if (!directory || !digest.test(key)) return null;
+  try {
+    const bytes = await read(directory, key + '.graph', MAX_RECORD);
+    if (!bytes) return null;
+    const record = deserialize(bytes), files = references(record);
+    if (!files || record.cacheKey !== key) return null;
+    const blobs = new Map(), restored = [];
+    for (const [name, id, hash, size] of files) {
+      let value = blobs.get(id);
+      if (!value) {
+        value = await read(directory, id + '.blob', MAX_BLOB);
+        if (!value || value.length !== size || cacheHash(value) !== id) return null;
+        blobs.set(id, value);
+      }
+      if (value.length !== size) return null;
+      restored.push([name, value, hash]);
+    }
+    return { ...record, format: 1, value: { ...record.value, files: restored } };
+  } catch { return null; }
+}
+
+// Concurrent eviction may turn a read into a miss, never into a partial hit.
+// Retain the newest complete records and their shared blobs within one budget.
+export async function pruneCompilationRecords(directory) {
+  try {
+    const entries = await readdir(directory, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries.slice(0, MAX_SCAN)) {
+      if (!entry.isFile() || !namePattern.test(entry.name)) continue;
+      const info = await lstat(path.join(directory, entry.name));
+      if (info.isFile() && !info.isSymbolicLink()) files.push({ name: entry.name, size: info.size, time: info.mtimeMs });
+    }
+    const blobs = new Map(files.filter(file => file.name.endsWith('.blob')).map(file => [file.name.slice(0, -5), file]));
+    const retained = new Set(); let total = 0, count = 0;
+    for (const file of files.filter(file => file.name.endsWith('.graph')).sort((a, b) => b.time - a.time)) {
+      let refs;
+      try { const bytes = await read(directory, file.name, MAX_RECORD); refs = bytes && references(deserialize(bytes)); } catch {}
+      const ids = refs && [...new Set(refs.map(item => item[1]))];
+      const added = file.size + (ids || []).reduce((sum, id) => sum + (retained.has(id + '.blob') ? 0 : blobs.get(id)?.size ?? MAX_DISK), 0);
+      if (ids && ids.every(id => blobs.has(id)) && count < MAX_RECORDS && total + added <= MAX_DISK) {
+        retained.add(file.name); for (const id of ids) retained.add(id + '.blob');
+        total += added; count++;
+      }
+    }
+    for (const file of files) if (!retained.has(file.name)) await unlink(path.join(directory, file.name)).catch(() => {});
+  } catch { /* Disk cache maintenance cannot fail a build. */ }
+}
+
+export async function writeCompilationRecord(directory, key, record) {
+  if (!directory || !digest.test(key)) return false;
+  try {
+    const files = [], written = new Set();
+    for (const [name, data, hash] of record.value.files) {
+      if (!(data instanceof Uint8Array) || data.byteLength > MAX_BLOB) return false;
+      const bytes = Buffer.from(data.buffer, data.byteOffset, data.byteLength), id = cacheHash(bytes);
+      files.push([name, id, hash, bytes.length]);
+      if (!written.has(id)) {
+        // Verify existing bytes before reuse, including a corrupted blob from an
+        // interrupted previous build. Atomic replacement repairs that entry.
+        const existing = await read(directory, id + '.blob', MAX_BLOB);
+        if (!existing || cacheHash(existing) !== id) await write(directory, id + '.blob', bytes);
+        written.add(id);
+      }
+    }
+    const saved = { ...record, format: 2, cacheKey: key, value: { ...record.value, files } };
+    if (!references(saved)) return false;
+    const bytes = serialize(saved);
+    if (bytes.length > MAX_RECORD) return false;
+    await write(directory, key + '.graph', bytes);
+    await pruneCompilationRecords(directory);
+    return true;
+  } catch { return false; }
+}

package/build/compiler.mjs

@@ -6,6 +6,7 @@ import { mkdir, writeFile, readFile } from 'node:fs/promises';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { createRequire } from 'node:module';
+import {createHash} from 'node:crypto';
 import { moduleResolutionPlugin, validateWebpackResolution } from './module-resolution.mjs';
 import { cachedLoader } from './loader-cache.mjs';
 import { incrementalBuild } from './incremental.mjs';
@@ -15,11 +16,19 @@ import {withSourceMaps,configureSourceMaps,inlineSourceMap} from './source-maps.
 import { optimizeImportsPlugins } from './optimize-imports.mjs';
 import {recordBuildAnalysis} from './analyze.mjs';
 import {recordDevDependencies,developmentDependencies,developmentStylePlans,developmentStyleDependencies,developmentModules} from './dev-dependencies.mjs';
+import {normalizeReactCompilerConfig,REACT_COMPILER_VERSION} from './react-compiler.mjs';
+import {withReactCompilerReporting,configureReactCompilerReporting,withReactCompilerGraph,recordReactCompilerGraph} from './react-compiler-report.mjs';
+import {withCompilationGraphCacheReporting,cachedGraphBuild} from './compilation-cache.mjs';
+export {reactCompilerReport} from './react-compiler-report.mjs';
+export {compilationGraphCacheReport} from './compilation-cache.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 const withCompilation = callback => withCompilationGraphCacheReporting(()=>withReactCompilerReporting(()=>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);
+  configureReactCompilerReporting({...options,config:{reactCompiler:options.config?.reactCompiler ? normalizeReactCompilerConfig(options.config.reactCompiler) : false},compilerVersion:REACT_COMPILER_VERSION});
+}
 export const buildAnalysisRecords=()=>compilation.getStore()?.analysis;
 export const buildAnalysisRoutes=()=>compilation.getStore()?.analysisRoutes;
 export const devDependencies=(project,manifest)=>developmentDependencies(compilation.getStore(),project,manifest);
@@ -118,7 +127,7 @@ async function targetConfig(state, target) {
       }
       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 (/^(?:process\.env\.(?:NODE_ENV|NEXT_RUNTIME|PRNEXT_)|__prnext|__PRNEXT_CACHE_COMPONENTS__(?:$|\.))/.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);
@@ -136,15 +145,29 @@ export async function validateCompilerConfig(config, root, {dev=false,edge=false
   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) {
+export async function build(options, { role = 'main' } = {}) {
+  if (role !== 'main' && role !== 'styles') throw new TypeError('Invalid compiler graph role');
   const state=compilation.getStore();
-  const result=await compileGraph(options);
-  recordBuildAnalysis(state,options,result);
-  recordDevDependencies(state,options,result);
-  return result;
+  const target=options.define?.['process.env.NEXT_RUNTIME']==='"edge"'?'edge':options.platform==='browser'?'browser':'node';
+  return withReactCompilerGraph(target,async()=>{
+    const result=await compileGraph(options,role);
+    recordReactCompilerGraph(result);
+    recordBuildAnalysis(state,options,result);
+    recordDevDependencies(state,options,result);
+    return result;
+  });
 }
-async function compileGraph(options) {
+async function compileGraph(options,role) {
   const state = compilation.getStore();
+  // The transform is captured by the framework's per-build callbacks. Give both
+  // esbuild and the webpack bridge a new graph identity when its options change,
+  // even if none of the application's source files have changed. The marker has
+  // no hooks or runtime output and leaves the opt-out graph exactly as before.
+  if ((options.plugins || []).some(plugin => framework.test(plugin.name)) && state?.config?.reactCompiler) {
+    const settings=normalizeReactCompilerConfig(state.config.reactCompiler);
+    const fingerprint=createHash('sha256').update(JSON.stringify([REACT_COMPILER_VERSION,settings])).digest('hex').slice(0,24);
+    options={...options,plugins:[...options.plugins,{name:'prnext-react-compiler-'+fingerprint,setup(){}}]};
+  }
   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,
@@ -161,7 +184,8 @@ async function compileGraph(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 && (projectGraph || !input.plugins?.length) ? incrementalBuild(input,{root:state.root,stage:state.stage,group:projectGraph?'project':'auxiliary',run:callback=>compilation.run(state,callback)}) : esbuild(input);
+  const nativeCompile = input => state?.incremental && (projectGraph || !input.plugins?.length) ? incrementalBuild(input,{root:state.root,stage:state.stage,group:projectGraph?'project':'auxiliary',role:projectGraph?role:'auxiliary',run:callback=>compilation.run(state,callback)}) : esbuild(input);
+  const compile = input => state?.root && state?.stage ? cachedGraphBuild(input,state,nativeCompile) : nativeCompile(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);

package/build/config.mjs

@@ -16,18 +16,29 @@ import { validateTurbopack } from './module-resolution.mjs';
 import { validateI18n } from './i18n.mjs';
 import { frameworkPackages } from './framework-imports.mjs';
 import { validateTypeScript } from './typescript.mjs';
+import {validateWorkerMemory} from './worker-memory.mjs';
 import { validateWorkerRetirement } from './worker-retirement.mjs';
 import {validateWorkerPreload} from './worker-preload.mjs';
 import { validateOptimizePackageImports } from './optimize-imports.mjs';
+import {validateDeploymentRetention} from './deployment-config.mjs';
+import {validatePrerenderConfig} from './prerender-config.mjs';
+import {validateHtmlOnly} from './html-only-config.mjs';
 import { validateProxyBodySize } from './proxy-body-config.mjs';
+import { normalizeReactCompilerConfig } from './react-compiler.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('partialPrefetching');
+supported.add('navigationCache');
+supported.add('workerMemory');
 supported.add('workerRetirement');
 supported.add('workerPreload');
+supported.add('deploymentRetention');
+supported.add('prerender');
+supported.add('htmlOnly');
 supported.add('cssEngine');
 supported.add('cacheMaxMemorySize');
 supported.add('turbopack');
@@ -90,10 +101,14 @@ export function validateProjectConfig(input, filename = 'project config') {
   // as in common process.env-based Next configuration wrappers.
   const config = { ...defaults, ...Object.fromEntries(Object.entries(input).filter(([,value]) => value !== undefined)) };
   if(config.typedRoutes!==undefined&&typeof config.typedRoutes!=='boolean')throw new TypeError('typedRoutes must be a boolean');
-  if(config.reactCompiler!==undefined&&config.reactCompiler!==false)throw new Error('reactCompiler currently supports only false. PRNext does not run the React Compiler transform; keep Next.js for builds that require it.');
+  config.reactCompiler = normalizeReactCompilerConfig(config.reactCompiler);
   config.typescript = validateTypeScript(config.typescript);
+  config.workerMemory = validateWorkerMemory(config.workerMemory);
   config.workerRetirement = validateWorkerRetirement(config.workerRetirement);
   config.workerPreload=validateWorkerPreload(config.workerPreload);
+  config.deploymentRetention=validateDeploymentRetention(config.deploymentRetention);
+  config.prerender=validatePrerenderConfig(config.prerender);
+  config.htmlOnly=validateHtmlOnly(config.htmlOnly);
   config.cssEngine ??= 'auto';
   if (!['auto','postcss','lightningcss'].includes(config.cssEngine)) throw new TypeError('cssEngine must be auto, postcss or lightningcss.');
   if (config.devIndicators !== false) {
@@ -122,6 +137,20 @@ export function validateProjectConfig(input, filename = 'project config') {
   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.partialPrefetching ??= false;
+  if (typeof config.partialPrefetching !== 'boolean') throw new TypeError('partialPrefetching must be a boolean');
+  if (config.partialPrefetching && !config.cacheComponents) throw new Error('partialPrefetching requires cacheComponents: true.');
+  if (config.navigationCache === false) config.navigationCache = { maxEntries: 0, ttlMs: 120000 };
+  else {
+    if (config.navigationCache === null) throw new TypeError('navigationCache must be false or an object with maxEntries and ttlMs.');
+    const value = config.navigationCache ?? {};
+    if (!value || typeof value !== 'object' || Array.isArray(value) || Object.keys(value).some(key => !['maxEntries', 'ttlMs', 'authCookies'].includes(key))) throw new TypeError('navigationCache must be false or an object with maxEntries, ttlMs and authCookies.');
+    const maxEntries = value.maxEntries ?? 4, ttlMs = value.ttlMs ?? 120000;
+    if (!Number.isSafeInteger(maxEntries) || maxEntries < 0 || maxEntries > 8 || !Number.isSafeInteger(ttlMs) || ttlMs < 1000 || ttlMs > 600000) throw new TypeError('navigationCache requires maxEntries between 0 and 8, and ttlMs between 1000 and 600000.');
+    const authCookies = value.authCookies;
+    if (authCookies !== undefined && (!Array.isArray(authCookies) || authCookies.length > 32 || authCookies.some(name => typeof name !== 'string' || !name || name.length > 256 || !/^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/.test(name)))) throw new TypeError('navigationCache.authCookies must contain at most 32 valid cookie names.');
+    config.navigationCache = { maxEntries, ttlMs, ...(authCookies !== undefined ? {authCookies: [...new Set(authCookies)].sort()} : {}) };
+  }
   config.cacheLife = cacheProfiles.profiles(config.cacheLife);
   for (const key of ['transpilePackages', 'serverExternalPackages']) {
     const names = config[key] ?? [];
@@ -135,11 +164,13 @@ export function validateProjectConfig(input, filename = 'project config') {
   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', 'optimizePackageImports', 'proxyClientMaxBodySize'].includes(key)) throw new Error(`${filename}: experimental.${key} is not supported by PRNext. It cannot be silently ignored.`);
+    if (!['nextScriptWorkers', 'serverActions', 'optimizePackageImports', 'proxyClientMaxBodySize', 'lazyDynamicImports'].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), optimizePackageImports: validateOptimizePackageImports(config.experimental.optimizePackageImports), proxyClientMaxBodySize: validateProxyBodySize(config.experimental.proxyClientMaxBodySize) };
+  const lazyDynamicImports=config.experimental.lazyDynamicImports===undefined?false:config.experimental.lazyDynamicImports;
+  if(typeof lazyDynamicImports!=='boolean')throw new Error(`${filename}: experimental.lazyDynamicImports must be a boolean.`);
+  config.experimental = { nextScriptWorkers, lazyDynamicImports, 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.`);
   }