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

package/build/react-compiler.mjs

@@ -1,19 +1,21 @@
 import { realpath } from 'node:fs/promises';
 import { createRequire } from 'node:module';
 import path from 'node:path';
-import { fileURLToPath } from 'node:url';
+import { fileURLToPath, pathToFileURL } from 'node:url';
 import { cachedAsyncTransform } from './transform-cache.mjs';
 import { extractSourceMap, inlineSourceMap, sourceMapsEnabled } from './source-maps.mjs';
-import { compilerEvent, recordReactCompilerTransform } from './react-compiler-report.mjs';
+import { compilerEvent, recordReactCompilerTransform, reactCompilerGraphTarget } from './react-compiler-report.mjs';
 
 const require = createRequire(import.meta.url);
-// Only metadata is loaded here. Disabled builds do not load Babel or the compiler.
+// Oxc is an optional peer. Disabled/Babel builds must not resolve it at all.
 export const REACT_COMPILER_VERSION = require('babel-plugin-react-compiler/package.json').version;
+export const OXC_REACT_COMPILER_VERSION = require('../package.json').peerDependencies['oxc-transform-react'];
 const BABEL_VERSION = require('@babel/core/package.json').version;
 const frameworkRoot = fileURLToPath(new URL('../', import.meta.url));
-const options = new Set(['compilationMode', 'panicThreshold', 'target']);
+const options = new Set(['backend', 'compilationMode', 'panicThreshold', 'target']);
 let implementation;
-const REPORT_CACHE_VERSION = 1;
+const oxcImplementations = new Map();
+const REPORT_CACHE_VERSION = 2;
 const optOutDirective = directives => directives?.map(item => item.value.value).find(value => value === 'use no memo' || value === 'use no forget') || false;
 
 function functionLocations(ast) {
@@ -48,14 +50,37 @@ export function normalizeReactCompilerConfig(value) {
     if (!options.has(key)) throw new TypeError(`reactCompiler.${String(key)} is not supported by PRNext.`);
   }
   const compilationMode = input.compilationMode === undefined ? 'infer' : input.compilationMode;
+  const backend = input.backend === undefined ? 'babel' : input.backend;
   const panicThreshold = input.panicThreshold === undefined ? 'none' : input.panicThreshold;
   const target = input.target === undefined ? '19' : input.target;
   if (!['infer', 'annotation'].includes(compilationMode)) throw new TypeError('reactCompiler.compilationMode must be infer or annotation.');
   if (!['none', 'critical_errors', 'all_errors'].includes(panicThreshold)) throw new TypeError('reactCompiler.panicThreshold must be none, critical_errors or all_errors.');
   if (target !== '19') throw new TypeError("reactCompiler.target must be '19'; PRNext requires React 19.");
-  return Object.freeze({ compilationMode, panicThreshold, target });
+  if (!['babel', 'oxc'].includes(backend)) throw new TypeError('reactCompiler.backend must be babel or oxc.');
+  return Object.freeze({ ...(backend === 'oxc' ? { backend } : {}), compilationMode, panicThreshold, target });
 }
 
+function oxcDependency(projectRoot) {
+  const candidates = projectRoot ? [createRequire(path.join(path.resolve(projectRoot), 'package.json')), require] : [require];
+  let metadata, owner, missing;
+  for (const candidate of candidates) {
+    try { metadata = candidate('oxc-transform-react/package.json'); owner = candidate; break; }
+    catch (cause) {
+      if (cause.code !== 'MODULE_NOT_FOUND' && cause.code !== 'ERR_MODULE_NOT_FOUND') throw cause;
+      missing = cause;
+    }
+  }
+  if (!owner) throw Object.assign(new Error(`reactCompiler.backend="oxc" requires oxc-transform-react@${OXC_REACT_COMPILER_VERSION}. Install it with npm install --save-dev oxc-transform-react@${OXC_REACT_COMPILER_VERSION}, or select backend:"babel".`, {cause: missing}), {code: 'PRNEXT_OXC_MISSING'});
+  if (metadata.name !== 'oxc-transform-react' || metadata.version !== OXC_REACT_COMPILER_VERSION) {
+    throw Object.assign(new Error(`reactCompiler.backend="oxc" requires oxc-transform-react@${OXC_REACT_COMPILER_VERSION}; found ${metadata.version || 'an unknown version'}. Install the supported version with npm install --save-dev oxc-transform-react@${OXC_REACT_COMPILER_VERSION}.`), {code: 'PRNEXT_OXC_VERSION'});
+  }
+  // Resolve and import from the same dependency owner. A global CLI must use
+  // its application's peer, while nested framework installations still work.
+  return {version: metadata.version, entry: owner.resolve('oxc-transform-react')};
+}
+
+export const reactCompilerVersion = (config, projectRoot) => config?.backend === 'oxc' ? oxcDependency(projectRoot).version : REACT_COMPILER_VERSION;
+
 function inside(root, filename) {
   const relative = path.relative(root, filename);
   return relative !== '' && relative !== '..' && !relative.startsWith('..' + path.sep) && !path.isAbsolute(relative);
@@ -75,14 +100,74 @@ function loadImplementation() {
   return implementation;
 }
 
+function loadOxcImplementation(dependency) {
+  if (!oxcImplementations.has(dependency.entry)) oxcImplementations.set(dependency.entry, Promise.all([import(pathToFileURL(dependency.entry).href), import('oxc-parser')]).then(([compiler, parser]) => {
+    if (compiler.__napiBindingTarget !== 'native') throw new Error('reactCompiler.backend="oxc" requires the native platform binding. Install optional dependencies or select backend:"babel".');
+    return { transform: compiler.transform, parse: parser.parseSync };
+  }).catch(cause => {
+    throw new Error(`Cannot load the native oxc-transform-react@${OXC_REACT_COMPILER_VERSION} compiler. Reinstall it with optional dependencies enabled on this platform, or select backend:"babel". ${cause.message}`, {cause});
+  }));
+  return oxcImplementations.get(dependency.entry);
+}
+
+/** Compose only source-map coordinates; application strings never enter this path. */
+async function composeOxcMap(output, input) {
+  if (!input || !output) return output;
+  const { TraceMap, decodedMappings, originalPositionFor, sourceContentFor, encodedMap } = await import('@jridgewell/trace-mapping');
+  const previous = new TraceMap(input), current = new TraceMap(output);
+  const sources = [], contents = [], names = [];
+  const mappings = decodedMappings(current).map(line => line.map(segment => {
+    if (segment.length < 4) return [segment[0]];
+    const position = originalPositionFor(previous, { line: segment[2] + 1, column: segment[3] });
+    if (position.source === null || position.line === null || position.column === null) return [segment[0]];
+    let source = sources.indexOf(position.source);
+    if (source < 0) { source = sources.length; sources.push(position.source); contents.push(sourceContentFor(previous, position.source)); }
+    const mapped = [segment[0], source, position.line - 1, position.column];
+    const name = position.name || (segment.length > 4 ? current.names[segment[4]] : null);
+    if (name) { let index = names.indexOf(name); if (index < 0) { index = names.length; names.push(name); } mapped.push(index); }
+    return mapped;
+  }));
+  return encodedMap(new TraceMap({ version: 3, sources, sourcesContent: contents, names, mappings }));
+}
+
+async function transformOxc(source, filename, normalized, { mapped, outputMode, loaderOutput, root, dependency }) {
+  const { transform, parse } = await loadOxcImplementation(dependency);
+  const { code, map } = extractSourceMap(source);
+  const lang = /\.tsx$/i.test(filename) ? 'tsx' : /\.[cm]?ts$/i.test(filename) ? 'ts' : 'jsx';
+  // The native transform does not expose directives. Inspect its original input
+  // with the existing Rust parser, never Babel, before entering executable modules.
+  const parsed = parse(filename, code, { lang, sourceType: 'unambiguous' });
+  const directives = [];
+  if (!parsed.errors.length) for (const statement of parsed.program.body) {
+    if (!statement.directive) break;
+    directives.push(statement.directive);
+  }
+  if (directives.includes('use server')) return { code: source, events: [], notes: ['Server Action module excluded.'] };
+  const result = await transform(filename, code, { lang, sourceType: 'unambiguous', jsx: 'preserve', sourcemap: mapped,
+    reactCompiler: { compilationMode: normalized.compilationMode, panicThreshold: normalized.panicThreshold,
+      target: normalized.target, outputMode, reportDiagnostics: true, sources: [''] } });
+  const diagnostics = result.errors.slice(0, 16).map(error => compilerEvent({
+    kind: result.fatal ? 'CompileError' : 'CompileDiagnostic', reason: error.message, detail: { category: 'Oxc' },
+  }, [], { root })).filter(Boolean);
+  const notes = ['Experimental Oxc backend; upstream does not expose per-function optimization events. Function optimization totals are unavailable.',
+    `Oxc output mode: ${outputMode}. TypeScript syntax is removed; JSX is preserved for the graph compiler.`];
+  if (normalized.compilationMode === 'annotation') notes.push('Annotation mode only selects functions with "use memo".');
+  if (loaderOutput) notes.push('Locations refer to JavaScript produced by the configured loader.');
+  return { code: result.fatal ? source : mapped ? inlineSourceMap(result.code, await composeOxcMap(result.map, map)) : result.code,
+    events: [], diagnostics, notes, fatal: result.fatal, truncated: result.errors.length > 16 };
+}
+
 /**
- * Run the official compiler on application source before JSX lowering, React
- * Refresh and framework instrumentation. JSX/TypeScript/module format remain
- * intact for the existing graph compiler. No app Babel configuration is loaded.
+ * Compile application source before JSX lowering and React Refresh. The Oxc
+ * development path instruments original JSX first, before native hoisting.
+ * JSX remains available to the graph compiler; Oxc also removes TypeScript.
+ * No application Babel configuration is loaded.
  */
 export function createReactCompilerTransform(projectRoot, config, { dev = false } = {}) {
   const normalized = normalizeReactCompilerConfig(config);
   if (!normalized) return async source => source;
+  const dependency = normalized.backend === 'oxc' ? oxcDependency(projectRoot) : null;
+  const compilerVersion = dependency?.version || REACT_COMPILER_VERSION;
   const root = path.resolve(projectRoot);
   const canonicalRoot = realpath(root).catch(error => {
     if (error.code === 'ENOENT') return root;
@@ -102,10 +187,15 @@ export function createReactCompilerTransform(projectRoot, config, { dev = false
       throw error;
     });
     if (excluded(actualRoot, actualFile) || inside(await canonicalFramework, actualFile)) return source;
+    const backend = normalized.backend || 'babel';
+    const graph = reactCompilerGraphTarget();
+    const outputMode = graph === 'node' || graph === 'edge' ? 'ssr' : 'client';
     let cacheHit = true;
     const serialized = await cachedAsyncTransform('react-compiler-report', source,
-      [REPORT_CACHE_VERSION, REACT_COMPILER_VERSION, BABEL_VERSION, normalized, root, actualRoot, filename, actualFile, !!dev, !!loaderOutput], async () => {
+      [REPORT_CACHE_VERSION, backend, compilerVersion, dependency?.entry, backend === 'babel' ? BABEL_VERSION : null,
+        normalized, root, actualRoot, filename, actualFile, !!dev, !!loaderOutput, backend === 'oxc' ? outputMode : null], async () => {
         cacheHit = false;
+        if (backend === 'oxc') return JSON.stringify(await transformOxc(source, filename, normalized, { mapped: sourceMapsEnabled(), outputMode, loaderOutput, root, dependency }));
         const { babel, compiler } = await loadImplementation();
         const mapped = sourceMapsEnabled();
         const { code, map } = extractSourceMap(source);
@@ -134,6 +224,7 @@ export function createReactCompilerTransform(projectRoot, config, { dev = false
       });
     const payload = JSON.parse(serialized);
     recordReactCompilerTransform(inside(root, filename) ? filename : path.resolve(root, path.relative(actualRoot, actualFile)), payload, { cacheHit });
+    if (payload.fatal) throw new Error(`React Compiler (oxc ${OXC_REACT_COMPILER_VERSION}) failed for ${filename}: ${payload.diagnostics.map(value => value.reason).join('; ') || 'Native compilation failed.'}`);
     return payload.code;
   };
 }

package/build/server-config.mjs

@@ -0,0 +1,35 @@
+import { isIP } from 'node:net';
+
+export function validateServerConfig(value) {
+  if (value === undefined) return { trustedProxies: [] };
+  if (!value || typeof value !== 'object' || Array.isArray(value) || Object.keys(value).some(key => !['publicOrigin', 'trustedProxies'].includes(key))) {
+    throw new TypeError('server must be an object with publicOrigin and trustedProxies.');
+  }
+  let publicOrigin;
+  if (value.publicOrigin !== undefined) {
+    const source = value.publicOrigin;
+    let url;
+    try { url = new URL(source); } catch { /* validated below */ }
+    if (typeof source !== 'string' || /[\s\\\u0000-\u001f\u007f]/.test(source) || !url || !['http:', 'https:'].includes(url.protocol) || url.username || url.password || url.pathname !== '/' || url.search || url.hash || source.includes('?') || source.includes('#')) {
+      throw new TypeError('server.publicOrigin must be an HTTP(S) origin without credentials, path, query or fragment, for example https://example.com.');
+    }
+    publicOrigin = url.origin;
+  }
+  const ranges = value.trustedProxies ?? [];
+  if (!Array.isArray(ranges) || ranges.length > 32 || ranges.some(range => {
+    if (typeof range !== 'string' || range.length > 64) return true;
+    const [address, bits, ...extra] = range.split('/');
+    const family = isIP(address);
+    return !family || extra.length || bits !== undefined && (!/^(0|[1-9]\d*)$/.test(bits) || Number(bits) > (family === 4 ? 32 : 128));
+  })) throw new TypeError('server.trustedProxies must contain at most 32 explicit IP addresses or CIDR ranges.');
+  const normalized = ranges.map(range => {
+    const [address, bits] = range.split('/');
+    if (isIP(address) !== 6) return range;
+    const mapped = /^\[::ffff:([\da-f]+):([\da-f]+)\]$/i.exec(new URL(`http://[${address}]`).hostname);
+    if (!mapped) return range;
+    if (bits !== undefined && Number(bits) < 96) throw new TypeError('Mapped IPv4 proxy CIDR ranges need a prefix of at least 96 bits.');
+    const high = parseInt(mapped[1], 16), low = parseInt(mapped[2], 16);
+    return `${high >>> 8}.${high & 255}.${low >>> 8}.${low & 255}${bits === undefined ? '' : '/' + (Number(bits) - 96)}`;
+  });
+  return { ...(publicOrigin ? { publicOrigin } : {}), trustedProxies: [...new Set(normalized)] };
+}

package/build/source-analysis.mjs

@@ -6,31 +6,81 @@ import {createHash} from 'node:crypto';
 const cache=new Map();
 let bytes=0,hits=0,misses=0;
 export const sourceAnalysisStats=()=>({entries:cache.size,bytes,hits,misses});
+const identifier=(node,name)=>node?.type==='Identifier'&&(name===undefined||node.name===name);
+const property=node=>node?.computed?node.property?.value:node?.property?.name;
+const moduleExports=node=>node?.type==='MemberExpression'&&identifier(node.object,'module')&&property(node)==='exports';
+function bindingNames(node,names){
+  if(!node)return;
+  if(identifier(node))names.add(node.name);
+  else if(node.type==='ObjectPattern')for(const item of node.properties)bindingNames(item.type==='RestElement'?item.argument:item.value,names);
+  else if(node.type==='ArrayPattern')for(const item of node.elements)bindingNames(item,names);
+  else if(node.type==='RestElement')bindingNames(node.argument,names);
+  else if(node.type==='AssignmentPattern')bindingNames(node.left,names);
+}
+function runtimeDeclaration(node,names){
+  if(!node||node.declare)return;
+  if(node.type==='VariableDeclaration')for(const item of node.declarations)bindingNames(item.id,names);
+  else if(['FunctionDeclaration','ClassDeclaration','TSEnumDeclaration','TSModuleDeclaration'].includes(node.type))bindingNames(node.id,names);
+}
 export function analyzeSource(source,file='source.js') {
   const key=file+'\0'+createHash('sha256').update(source).digest('hex');
   if(cache.has(key)){const hit=cache.get(key);cache.delete(key);cache.set(key,hit);hits++;return hit.value;}
   misses++;
-  const parsed=parseSync(file,source,{sourceType:'unambiguous',allowReturnOutsideFunction:true});
+  // Custom loaders also return JSX under their original asset filenames (for
+  // example .svg). Match the compiler's JSX fallback for non-TypeScript inputs,
+  // preserving TypeScript's extension rules, including angle assertions in .ts.
+  const parsed=parseSync(file,source,{sourceType:'unambiguous',allowReturnOutsideFunction:true,...(/\.(?:[cm]?ts|tsx)$/.test(file)?{}:{lang:'jsx'})});
   if(parsed.errors.length)throw new SyntaxError(`${file}: ${parsed.errors.map(error=>error.message).join('; ')}`);
   const program=parsed.program,directives=[];
   for(const node of program.body){if(!node.directive)break;directives.push(node.directive);}
-  const imports=[];
-  let computedRequire=false;
+  const imports=[],runtimeExports=new Set(),exportStars=[];
+  for(const node of program.body){
+    if(node.exportKind==='type')continue;
+    if(node.type==='ExportDefaultDeclaration'&&!node.declaration?.declare&&!['TSInterfaceDeclaration','TSTypeAliasDeclaration'].includes(node.declaration?.type))runtimeExports.add('default');
+    if(node.type==='ExportNamedDeclaration'){
+      runtimeDeclaration(node.declaration,runtimeExports);
+      for(const item of node.specifiers)if(item.exportKind!=='type')runtimeExports.add(item.exported.name??item.exported.value);
+    }
+    if(node.type==='ExportAllDeclaration'){
+      if(node.exported)runtimeExports.add(node.exported.name??node.exported.value);
+      else exportStars.push(node.source.value);
+    }
+  }
+  let computedRequire=false,hasServerDirective=false;
   const pending=[program];
   while(pending.length){
     const node=pending.pop();
+    if(node.directive==='use server')hasServerDirective=true;
     if(['ImportDeclaration','ExportNamedDeclaration','ExportAllDeclaration'].includes(node.type)&&node.source&&node.importKind!=='type'&&node.exportKind!=='type')imports.push({path:node.source.value,kind:'import-statement'});
     if(node.type==='ImportExpression'&&typeof node.source?.value==='string')imports.push({path:node.source.value,kind:'dynamic-import'});
     if(node.type==='CallExpression'&&node.callee?.type==='Identifier'&&node.callee.name==='require'){
       const argument=node.arguments[0];
       if(argument?.type==='Literal'&&typeof argument.value==='string')imports.push({path:argument.value,kind:'require-call'});else computedRequire=true;
     }
+    if(node.type==='CallExpression'&&node.callee?.type==='MemberExpression'&&identifier(node.callee.object,'Object')&&property(node.callee)==='defineProperty'&&identifier(node.arguments[0],'exports')&&typeof node.arguments[1]?.value==='string'&&node.arguments[1].value!=='__esModule'){
+      runtimeExports.add('default');runtimeExports.add(node.arguments[1].value);
+    }
+    if(node.type==='AssignmentExpression'&&node.left.type==='MemberExpression'){
+      const left=node.left;
+      if(moduleExports(left)){
+        runtimeExports.add('default');
+        if(node.right.type==='ObjectExpression')for(const item of node.right.properties){
+          const key=item.computed?item.key?.value:item.key?.name??item.key?.value;
+          if(typeof key==='string')runtimeExports.add(key);
+        }
+      }
+      if(identifier(left.object,'exports')||moduleExports(left.object)){
+        runtimeExports.add('default');if(typeof property(left)==='string')runtimeExports.add(property(left));
+      }
+    }
     for(const value of Object.values(node)){
       if(Array.isArray(value)){for(let i=value.length-1;i>=0;i--)if(value[i]?.type)pending.push(value[i]);}
       else if(value&&typeof value==='object'&&value.type)pending.push(value);
     }
   }
-  const value={program,directives,imports,computedRequire,frameworkBoundary:directives.some(item=>item==='use client'||item==='use server')};
+  runtimeExports.delete('__esModule');
+  const value=Object.freeze({program,directives:Object.freeze(directives),imports:Object.freeze(imports.map(Object.freeze)),computedRequire,hasServerDirective,
+    runtimeExports:Object.freeze([...runtimeExports]),exportStars:Object.freeze(exportStars),frameworkBoundary:directives.some(item=>item==='use client'||item==='use server')});
   // ASTs are substantially larger than source. Bound both count and estimated
   // retained size; large individual npm modules are analyzed without retention.
   const size=Buffer.byteLength(source)*16+Buffer.byteLength(file);

package/build/static-adapter.mjs

@@ -7,6 +7,8 @@ import { OUTPUT_POINTER, prepareBuildDirectory, readBuildDirectory, validateDist
 import { writeBuildOutput } from './output-contract.mjs';
 import { precompressBuild } from './precompress.mjs';
 import { withBuildLock } from './build-lock.mjs';
+import {withCompilationStorage} from './compilation-storage.mjs';
+import {reclaimBuildStages,trackBuildStage} from './build-retention.mjs';
 import { plainStaticPath } from './static-input.mjs';
 
 const MAX_FILES = 20000, MAX_BYTES = 512 * 1024 * 1024;
@@ -15,7 +17,7 @@ const urlFor = file => '/' + file.split('/').map(encodeURIComponent).join('/');
 
 /** Import an already-built public directory. Never evaluate its config or code. */
 export async function buildStatic(directory, { from = 'dist', spa = false, distDir, dev = false } = {}) {
-  return withBuildLock(directory, root => importStatic(root, { from, spa, distDir, dev }));
+  return withBuildLock(directory, async root => {await reclaimBuildStages(root);return withCompilationStorage(root,()=>importStatic(root, { from, spa, distDir, dev }));});
 }
 
 async function importStatic(directory, { from, spa, distDir, dev }) {
@@ -41,6 +43,7 @@ async function importStatic(directory, { from, spa, distDir, dev }) {
 
   const id = randomUUID(), stage = path.join(root, `.prnext-build-${id}`);
   const backup = path.join(root, `.prnext-backup-${id}`), pointer = path.join(root, `.prnext-output-${id}.tmp`);
+  const recovery=await trackBuildStage(root,{stage,backup}).catch(()=>null);
   const manifest = { version: 1, buildId: id, config: { staticOnly: true, staticFallback: spa, compress: true, poweredByHeader: true }, routes: [], prerendered: [] };
   const paths = new Set();
   let count = 0, bytes = 0, previous = false, published = false;
@@ -99,10 +102,11 @@ async function importStatic(directory, { from, spa, distDir, dev }) {
       if (previous) await rename(backup, destination);
       throw error;
     }
-    if (previous) await rm(backup, { recursive: true, force: true });
+    await recovery?.committed().catch(()=>{});
+    if (!recovery&&previous) await rm(backup, { recursive: true, force: true });
     return { ...manifest, outputDirectory: destination, files: count, bytes };
   } finally {
     await rm(pointer, { force: true });
-    await rm(stage, { recursive: true, force: true });
+    if(recovery)await recovery.cleanup();else await rm(stage, { recursive: true, force: true });
   }
 }

package/build/transform.mjs

@@ -37,17 +37,49 @@ function relativeChunksUncached(source,chunks,prefix) {
   return source;
 }
 
+function rewriteChunkSource(source,map,file,chunks,publicPath){
+  const result=relativeServerChunkImports(inlineSourceMap(source,map),chunks,publicPath);
+  if(map){
+    const mapped=extractSourceMap(result);
+    return {source:mapped.code.replace(/\/\/[#@]\s*sourceMappingURL=[^\s]+/g,'')+'\n//# sourceMappingURL='+path.basename(file)+'.map\n',map:JSON.stringify({...mapped.map,file:path.basename(file)})};
+  }
+  return {source:result};
+}
+
+/** Rewrite before the first disk write, without modifying compiler/cache buffers. */
+export function rewriteServerChunkOutputFiles(files,chunks,publicPath,importers){
+  const outputs=new Map(files.map(file=>[path.resolve(file.path),file])),replacements=new Map();
+  const replace=(file,source)=>{
+    const contents=Buffer.from(source),metadata=Object.getOwnPropertyDescriptors(file);
+    // esbuild's hash describes the original buffer. Do not retain a stale hash.
+    // Reading/spreading esbuild's lazy text getter would decode the old buffer
+    // again and retain that string even though only the new bytes are needed.
+    delete metadata.hash;delete metadata.contents;delete metadata.text;
+    const output=Object.create(Object.getPrototypeOf(file),metadata);
+    Object.defineProperties(output,{contents:{value:contents,writable:true,enumerable:true,configurable:true},text:{get(){return this.contents.toString();},enumerable:true,configurable:true}});
+    replacements.set(file,output);
+  };
+  for(const file of files){
+    if(!file.path.endsWith('.mjs')||importers&&!importers.has(path.resolve(file.path)))continue;
+    const source=Buffer.from(file.contents.buffer,file.contents.byteOffset,file.contents.byteLength).toString();
+    if(!source.includes(publicPath.replace(/\/+$/,'')+'/'))continue;
+    const mapFile=sourceMapsEnabled()&&outputs.get(path.resolve(file.path+'.map'));
+    const map=mapFile?JSON.parse(Buffer.from(mapFile.contents).toString()):undefined;
+    const result=rewriteChunkSource(source,map,file.path,chunks,publicPath);
+    if(result.source!==source)replace(file,result.source);
+    if(mapFile)replace(mapFile,result.map);
+  }
+  return files.map(file=>replacements.get(file)||file);
+}
+
 export async function rewriteServerChunks(file,chunks,publicPath){
   const source=await readFile(file,'utf8');
   if(!source.includes(publicPath.replace(/\/+$/,'')+'/'))return;
   let map;
   if(sourceMapsEnabled())try{map=JSON.parse(await readFile(file+'.map','utf8'));}catch(error){if(error.code!=='ENOENT')throw error;}
-  const result=relativeServerChunkImports(inlineSourceMap(source,map),chunks,publicPath);
-  if(map){
-    const mapped=extractSourceMap(result);
-    await writeFile(file+'.map',JSON.stringify({...mapped.map,file:path.basename(file)}));
-    await writeFile(file,mapped.code.replace(/\/\/[#@]\s*sourceMappingURL=[^\s]+/g,'')+'\n//# sourceMappingURL='+path.basename(file)+'.map\n');
-  }else await writeFile(file,result);
+  const result=rewriteChunkSource(source,map,file,chunks,publicPath);
+  if(map)await writeFile(file+'.map',result.map);
+  await writeFile(file,result.source);
 }
 
 function parserOptions(filename) {

package/build/typescript-dev.mjs

@@ -3,7 +3,7 @@ import {access} from 'node:fs/promises';
 import {resolveTypeScript} from './typescript-toolchain.mjs';
 import path from 'node:path';
 import {privateCacheDirectory} from './persistent-cache.mjs';
-export async function startTypeChecker(root,config,notify,{fork:spawnChecker=fork,recheckDelayMs=3000}={}){
+export async function startTypeChecker(root,config,notify,{fork:spawnChecker=fork,recheckDelayMs=3000,onBeforeChild=()=>{},onChild=()=>{}}={}){
   const noop={inactive:true,async close(){}};
   if(config.typescript?.devChecks===false)return noop;
   const filename=path.resolve(root,config.typescript?.tsconfigPath||'tsconfig.json');try{await access(filename);}catch{return noop;}
@@ -13,7 +13,9 @@ export async function startTypeChecker(root,config,notify,{fork:spawnChecker=for
   function launch(){
     if(closed)return;
     const worker=toolchain.native?'./typescript-native-worker.mjs':'./typescript-dev-worker.mjs';
+    const ticket=onBeforeChild();
     child=spawnChecker(new URL(worker,import.meta.url),[toolchain.compiler,filename,toolchain.native?'watch':directory?path.join(directory,'project.tsbuildinfo'):''],{cwd:root,execArgv:['--max-old-space-size=512'],stdio:['ignore','ignore','pipe','ipc'],windowsHide:true});
+    onChild(child,ticket);
     const current=child;
     let details='',healthyAt=0;child.stderr.on('data',chunk=>{details=(details+chunk).slice(-2048);});
     child.on('message',message=>{

package/cli.mjs

@@ -38,12 +38,15 @@ Use prnext for portable scripts; prn is a shortcut on compatible shells.
   prnext docs --ai [topic]              Read the AI guide bundled with this version
   prnext docs --ai --init [directory]   Add a guide pointer to the project's AGENTS.md
   prnext routes [directory]             Display compiled routes
-  prnext check [directory] [--json]      Diagnose config, routes, Node, native and dependencies
+  prnext check [directory] [--production] [--json]  Check config, deployment and dependencies
   prnext typegen [directory] [--json]    Generate route types without building the app
   prnext typecheck [directory] [--json]  Generate types and check TypeScript without building
   prnext inspect [directory] [--json|--otlp] Explain routes, health and sampled timings
   prnext analyze [directory] [--json] [--max-js 150]  Browser bundles and budget (kB)
   prnext compiler [directory] [--json]  React Compiler results from the last successful build
+  prnext cache [directory] [--json]     Show compilation cache sizes and disk budget
+  prnext cache [directory] --prune [--dry-run] [--max-bytes N] [--json]
+                                       Reclaim regenerable compilation caches
   prnext host [prnext.host.json]         Host built apps by hostname; wake on demand
   prnext host [config] --check           Validate hosting configuration and builds
   prnext host [config] --status [--json]  Show memory, process and idle status
@@ -109,6 +112,10 @@ function stop(child) {
 async function main() {
   if (['help', '--help', '-h'].includes(command)) { console.log(help); return; }
   if (['--version', '-v'].includes(command)) { console.log(packageManifest.version); return; }
+  if(command==='cache'){
+    const {cacheCommand}=await import('./build/cache-command.mjs');
+    await cacheCommand(argv);return;
+  }
   if (command === 'create') {
     const { createHelp, parseCreateArgs, createProject } = await import('./build/create.mjs');
     if (argv.length === 1 && ['--help', '-h'].includes(argv[0])) { console.log(createHelp); return; }
@@ -313,12 +320,12 @@ async function main() {
     process.env.PWD = root;
   }
   if (command === 'check') {
-    if (args.some(arg => arg !== '--json')) throw new Error('check accepts only [directory] and --json');
+    if (args.some(arg => !['--json','--production'].includes(arg))||new Set(args).size!==args.length) throw new Error('check accepts [directory], --production and --json once each');
     const { checkProject } = await import('./build/check.mjs');
-    const report = await checkProject(root);
+    const report = await checkProject(root,{production:args.includes('--production')});
     if (args.includes('--json')) console.log(JSON.stringify(report, null, 2));
     else {
-      console.log(`PRNext preflight ${report.ok ? 'passed' : 'failed'}: ${root}`);
+      console.log(`PRNext ${report.mode==='production'?'production ':''}preflight ${report.ok ? 'passed' : 'failed'}: ${root}`);
       console.log(`${report.routes.length} routes. Installed versions: ${Object.entries(report.versions).map(([name,version])=>`${name}@${version||'missing'}`).join(', ')}`);
       for (const item of report.diagnostics) {
         const output = item.severity === 'error' ? console.error : console.log;
@@ -380,7 +387,9 @@ async function main() {
   const binary = await resolveNativeBinary();
   if(command==='dev') {const {develop}=await import('./runtime/development.mjs');await develop(root,args,binary);return;}
   const outputDirectory = await readBuildDirectory(root);
-  const serverEnvironment = {...process.env,NODE_ENV:process.env.NODE_ENV||'production'};
+  const serverEnvironment = command==='start'
+    ? (await import('./runtime/env.mjs')).productionEnvironment(root)
+    : {...process.env,NODE_ENV:process.env.NODE_ENV||'production'};
   if(command==='start'&&serverEnvironment.NODE_ENV!=='development'){
     if(replaceWithNative(binary,['start',root,'--worker',path.join(root,outputDirectory,'runtime/worker.mjs'),
       '--node',process.execPath,...args],serverEnvironment))return;

package/compat/app-layout-context.cjs

@@ -12,17 +12,21 @@ function ActivitySlot({ identity, children, authorizationKey }) {
   const router = React.useContext(AppRouterContext);
   const epoch = retention?.epoch ?? 0;
   const authorizationEpoch = retention?.authorizationEpoch ?? 0;
+  const flight = retention?.flight;
   const registrations = React.useRef(new Set());
   const serial = React.useRef(0);
   const [saved, setSaved] = React.useState(() => ({ epoch, authorizationEpoch, active: identity, entries: new Map() }));
   let entries = saved.entries;
   const current = entries.get(identity);
-  if (saved.epoch !== epoch || saved.authorizationEpoch !== authorizationEpoch || current?.children !== children || current?.router !== router || current?.authorizationKey !== authorizationKey) {
+  const incompleteInactive = [...entries].some(([key, entry]) => key !== identity && entry.flight?.complete === false);
+  if (saved.epoch !== epoch || saved.authorizationEpoch !== authorizationEpoch || current?.children !== children || current?.router !== router || current?.authorizationKey !== authorizationKey || current?.flight !== flight || incompleteInactive) {
     const sameAuthorization = saved.authorizationEpoch === authorizationEpoch && !(current?.authorizationKey && authorizationKey && current.authorizationKey !== authorizationKey);
-    entries = saved.epoch === epoch && sameAuthorization ? new Map(entries) : new Map();
+    // Aborted lazy Flight rows cannot remain in an inactive Activity. Restore
+    // complete siblings while keeping the current shared layout's React key.
+    entries = saved.epoch === epoch && sameAuthorization ? new Map([...entries].filter(([key, entry]) => key === identity || entry.flight?.complete !== false)) : new Map();
     const preserve = current && saved.authorizationEpoch === authorizationEpoch && (sameAuthorization && (saved.epoch === epoch || saved.active === identity)
       || !retention?.strictAuthorization && saved.active === identity);
-    entries.set(identity, { children, router, authorizationKey, token: preserve ? current.token : {}, reactKey: preserve ? current.reactKey : ++serial.current });
+    entries.set(identity, { children, router, authorizationKey, flight, token: preserve ? current.token : {}, reactKey: preserve ? current.reactKey : ++serial.current });
     setSaved({ epoch, authorizationEpoch, active: identity, entries });
   }
   React.useLayoutEffect(() => {

package/compat/flight-delta.cjs

@@ -3,7 +3,7 @@
 const WINDOW = 32, MAX_VALUE = 2 * 1024 * 1024, MAX_RESPONSE = 16 * 1024 * 1024;
 const TYPE = 'application/x-prnext-flight-delta';
 const MAGIC = new Uint8Array([80,82,68,49]);
-const BLOCK_BYTES = 32 * 1024, MAX_COMMANDS_PER_CHUNK = 256, MAX_COMMANDS = 2048;
+const BLOCK_BYTES = 32 * 1024, MAX_COMMANDS_PER_CHUNK = 256, MAX_COMMANDS = 2048, MAX_CAPTURE_PARTS = 2048;
 let POWER = 1; for(let n=1;n<WINDOW;n++) POWER = Math.imul(POWER,31) >>> 0;
 function hash(bytes,offset) { let result=0; for(let n=0;n<WINDOW;n++) result=(Math.imul(result,31)+bytes[offset+n])>>>0; return result; }
 function createIndex(base) {
@@ -44,12 +44,47 @@ function blocks(parts) {
   for(const part of parts)for(let offset=0;offset<part.length;){const n=Math.min(BLOCK_BYTES-size,part.length-offset);pending.push(part.subarray(offset,offset+n));size+=n;offset+=n;if(size===BLOCK_BYTES)flush();}
   flush();return output;
 }
-function collectStream(source,{onComplete,onCancel,onFinally,capture=true}={}) {
-  const reader=source.getReader(), parts=[];let size=0,complete=false,finished=false;
+// Only the worker bridge registers streams here. Their backing allocations
+// crossed a transfer boundary, have no producer aliases, and the framework's
+// outgoing transport does not mutate or transfer them again. Arbitrary React,
+// fetch and application streams retain the defensive per-chunk copy.
+// Even an owned partial view is copied: retaining its much larger backing
+// allocation would defeat the byte-based capture limit.
+const ownedStreams=new WeakSet();
+function ownFlightStream(source){ownedStreams.add(source);return source;}
+function collectStream(source,{onComplete,onEnd,onCancel,onFinally,capture=true}={}) {
+  const owned=ownedStreams.has(source);
+  const reader=source.getReader(), parts=[];let size=0,complete=false,finished=false,cancelled=false;
   const finish=()=>{if(!finished){finished=true;onFinally?.();}};
   return new ReadableStream({
-    async pull(controller) {try{const next=await reader.read();if(next.done){complete=true;if(capture&&size<=MAX_VALUE)onComplete?.(join(parts,size));parts.length=0;finish();controller.close();return;}if(!(next.value instanceof Uint8Array))throw new Error('Invalid Flight bytes');size+=next.value.length;if(size>MAX_RESPONSE)throw new Error('Flight exceeds transport budget');if(capture&&size<=MAX_VALUE)parts.push(next.value.slice());else parts.length=0;controller.enqueue(next.value);}catch(error){parts.length=0;finish();controller.error(error);await reader.cancel(error).catch(()=>{});}},
-    async cancel(reason){parts.length=0;finish();if(!complete)onCancel?.();await reader.cancel(reason);},
+    async pull(controller) {
+      try {
+        const next=await reader.read();
+        if(cancelled)return;
+        if(next.done){
+          complete=true;
+          if(capture)onComplete?.(join(parts,size));
+          parts.length=0;onEnd?.();finish();controller.close();return;
+        }
+        const value=next.value;
+        if(!(value instanceof Uint8Array))throw new Error('Invalid Flight bytes');
+        size+=value.length;
+        if(size>MAX_RESPONSE)throw new Error('Flight exceeds transport budget');
+        if(capture){
+          // Limits include the number of retained allocations, not just their
+          // payload bytes. An abandoned capture never interrupts the response.
+          if(size>MAX_VALUE||value.length&&parts.length>=MAX_CAPTURE_PARTS){capture=false;parts.length=0;}
+          else if(value.length){
+            const wholeOwned=owned&&value.buffer instanceof ArrayBuffer&&value.byteOffset===0&&value.byteLength===value.buffer.byteLength;
+            // Buffer.slice() aliases its producer's backing allocation. The
+            // plain Uint8Array constructor always copies just the visible bytes.
+            parts.push(wholeOwned?value:new Uint8Array(value));
+          }
+        }
+        controller.enqueue(value);
+      }catch(error){parts.length=0;finish();if(cancelled)return;controller.error(error);await reader.cancel(error).catch(()=>{});}
+    },
+    async cancel(reason){cancelled=true;parts.length=0;finish();if(!complete)onCancel?.();await reader.cancel(reason);},
   },{highWaterMark:0});
 }
 async function deltaStream(source,base,{assess}={}) {
@@ -58,10 +93,10 @@ async function deltaStream(source,base,{assess}={}) {
   // A short first chunk always selects ordinary Flight. Do not build a base
   // index that this response cannot use, or wait for a later streaming chunk.
   let index=first.value.length>=WINDOW&&base instanceof Uint8Array&&base.length<=MAX_VALUE?createIndex(base):null;
-  const profitable=(raw,frames,initial)=>frames&&frames.reduce((n,b)=>n+b.length,0)+(initial?5:1)<raw.length*0.9&&(!assess||assess(raw,join(initial?[MAGIC,...frames,new Uint8Array([2])]:frames,frames.reduce((n,b)=>n+b.length,0)+(initial?5:0)))===true);
+  const profitable=async(raw,frames,initial)=>frames&&frames.reduce((n,b)=>n+b.length,0)+(initial?5:1)<raw.length*0.9&&(!assess||await assess(raw,join(initial?[MAGIC,...frames,new Uint8Array([2])]:frames,frames.reduce((n,b)=>n+b.length,0)+(initial?5:0)))===true);
   const firstFrames=index&&first.value.length>=WINDOW?encodeChunk(first.value,base,index):null;
   let useDelta;
-  try{useDelta=!!profitable(first.value,firstFrames,true);}catch(error){await reader.cancel(error).catch(()=>{});throw error;}
+  try{useDelta=!!(await profitable(first.value,firstFrames,true));}catch(error){await reader.cancel(error).catch(()=>{});throw error;}
   let pending=useDelta?blocks([MAGIC,...firstFrames]):[first.value], pendingAt=0,ended=false,tail=false,commands=firstFrames?.commands||0;
   if(!useDelta){base=undefined;index=undefined;}
   return {delta:!!useDelta,body:new ReadableStream({
@@ -69,7 +104,7 @@ async function deltaStream(source,base,{assess}={}) {
       if(pendingAt===pending.length&&!ended){pending=[];pendingAt=0;const next=await reader.read();
         if(next.done){ended=true;if(useDelta&&!tail)pending=[new Uint8Array([2])];}
         else if(useDelta&&!tail){const encoded=encodeChunk(next.value,base,index);commands+=encoded?.commands||0;
-          if(commands>MAX_COMMANDS||!profitable(next.value,encoded,false)){tail=true;index=undefined;base=undefined;pending=blocks([new Uint8Array([3]),next.value]);}
+          if(commands>MAX_COMMANDS||!await profitable(next.value,encoded,false)){tail=true;index=undefined;base=undefined;pending=blocks([new Uint8Array([3]),next.value]);}
           else pending=blocks(encoded);
         }else pending=[next.value];
       }
@@ -134,19 +169,19 @@ function createFlightTransport() {
   let current,serial=0;
   return {
     snapshot(){return current;},
-    async response(response,base) {
+    async response(response,base,{onEnd}={}) {
       const version=++serial;
       const token=response.headers.get('x-prnext-flight-token'), headers=new Headers(response.headers);
       let source=response.body;
-      if(!source)return response;
+      if(!source){onEnd?.();return response;}
       if(headers.get('content-type')?.startsWith(TYPE)) {
         if(!base||headers.get('x-prnext-flight-base')!==base.token){await source.cancel();throw new Error('Missing Flight delta base');}
         source=decodeStream(source,base.bytes);
       }
       headers.set('content-type','text/x-component; charset=utf-8');headers.delete('content-length');headers.delete('content-encoding');
-      return new Response(collectStream(source,{capture:!!token&&/^[a-f0-9]{48}$/.test(token),onComplete:bytes=>{if(version===serial&&token&&/^[a-f0-9]{48}$/.test(token))current={token,bytes};}}),{status:response.status,statusText:response.statusText,headers});
+      return new Response(collectStream(source,{capture:!!token&&/^[a-f0-9]{48}$/.test(token),onEnd,onComplete:bytes=>{if(version===serial&&token&&/^[a-f0-9]{48}$/.test(token))current={token,bytes};}}),{status:response.status,statusText:response.statusText,headers});
     },
     clear(){serial++;current=undefined;},
   };
 }
-module.exports={TYPE,MAX_VALUE,createIndex,encodeChunk,deltaStream,decodeStream,collectStream,createFlightTransport};
+module.exports={TYPE,MAX_VALUE,createIndex,encodeChunk,deltaStream,decodeStream,collectStream,createFlightTransport,ownFlightStream};