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

package/build/source-analysis.mjs

@@ -1,36 +1,139 @@
 import {parseSync} from 'oxc-parser';
 import {createHash} from 'node:crypto';
+import parserPackage from 'oxc-parser/package' with {type:'json'};
+import {cachedValidatedTransform} from './transform-cache.mjs';
 
 // Read-only analyses share one Rust parse. Transformations still use Babel's
 // binding-aware AST: ESTree nodes must never be passed to Babel transforms.
 const cache=new Map();
 let bytes=0,hits=0,misses=0;
-export const sourceAnalysisStats=()=>({entries:cache.size,bytes,hits,misses});
+const summaries=new Map();
+let summaryBytes=0,summaryHits=0,summaryMisses=0,summaryReplays=0;
+const SUMMARY_BYTES=8*1024*1024,SUMMARY_ENTRIES=4096,SUMMARY_ITEM=128*1024;
+export const sourceAnalysisStats=()=>({entries:cache.size,bytes,hits,misses,
+  summaries:{entries:summaries.size,bytes:summaryBytes,hits:summaryHits,misses:summaryMisses,replays:summaryReplays}});
+const summaryFields=['directives','imports','computedRequire','hasServerDirective','runtimeExports','exportStars','frameworkBoundary'];
+const text=value=>typeof value==='string'&&value.length<=32768;
+const texts=value=>Array.isArray(value)&&value.length<=4096&&value.every(text);
+function validSummary(value){
+  return value&&Object.getPrototypeOf(value)===Object.prototype&&Object.keys(value).length===summaryFields.length
+    &&summaryFields.every(name=>Object.hasOwn(value,name))&&texts(value.directives)&&texts(value.runtimeExports)&&texts(value.exportStars)
+    &&['computedRequire','hasServerDirective','frameworkBoundary'].every(name=>typeof value[name]==='boolean')
+    &&Array.isArray(value.imports)&&value.imports.length<=4096&&value.imports.every(item=>item&&Object.getPrototypeOf(item)===Object.prototype
+      &&Object.keys(item).length===2&&text(item.path)&&['import-statement','dynamic-import','require-call'].includes(item.kind));
+}
+function immutableSummary(value){
+  return Object.freeze({directives:Object.freeze([...value.directives]),imports:Object.freeze(value.imports.map(item=>Object.freeze({path:item.path,kind:item.kind}))),
+    computedRequire:value.computedRequire,hasServerDirective:value.hasServerDirective,runtimeExports:Object.freeze([...value.runtimeExports]),
+    exportStars:Object.freeze([...value.exportStars]),frameworkBoundary:value.frameworkBoundary});
+}
+
+/** Pure, versioned facts only: no AST, source, resolver, registry or generation. */
+export function analyzeSourceSummary(source,file='source.js'){
+  const digest=createHash('sha256').update(source).digest('hex'),key=file+'\0'+digest;
+  const found=summaries.get(key);
+  if(found){summaries.delete(key);summaries.set(key,found);summaryHits++;return found.value;}
+  summaryMisses++;
+  let produced=false,producedAnalysis;
+  const validate=raw=>{
+    if(typeof raw!=='string'||Buffer.byteLength(raw)>SUMMARY_ITEM)return false;
+    const record=JSON.parse(raw);
+    return record&&Object.keys(record).length===5&&record.version===1&&record.parser===parserPackage.version
+      &&record.file===file&&record.digest===digest&&validSummary(record.analysis);
+  };
+  const produce=()=>{
+    produced=true;
+    const analysis=producedAnalysis=analyzeSource(source,file);
+    return JSON.stringify({version:1,parser:parserPackage.version,file,digest,analysis:Object.fromEntries(summaryFields.map(name=>[name,analysis[name]]))});
+  };
+  // Oversized summaries remain ordinary uncached parses, preserving the old
+  // accepted input surface without weakening bounded disk/memory retention.
+  let raw,value;
+  try{raw=cachedValidatedTransform('source-summary',source,[file,parserPackage.version,'v1'],validate,produce);value=JSON.parse(raw).analysis;}
+  catch(error){if(error?.message!=='Invalid typed compiler cache result')throw error;value=Object.fromEntries(summaryFields.map(name=>[name,producedAnalysis[name]]));}
+  if(!produced)summaryReplays++;
+  const immutable=immutableSummary(value),size=Buffer.byteLength(JSON.stringify(value))*2+Buffer.byteLength(key)*2;
+  if(size<=SUMMARY_ITEM){
+    while(summaries.size&&(summaries.size>=SUMMARY_ENTRIES||summaryBytes+size>SUMMARY_BYTES)){const[old,entry]=summaries.entries().next().value;summaries.delete(old);summaryBytes-=entry.size;}
+    summaries.set(key,{value:immutable,size});summaryBytes+=size;
+  }
+  return immutable;
+}
+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/standalone-copy.mjs

@@ -0,0 +1,48 @@
+import {lstat, realpath, mkdir, copyFile, stat} from 'node:fs/promises';
+import path from 'node:path';
+import {mapConcurrent} from './concurrent.mjs';
+
+const within = (root, file) => file === root || file.startsWith(root + path.sep);
+const version = info => [info.dev, info.ino, info.size, info.mtimeMs, info.ctimeMs];
+const unchanged = (left, right) => version(left).every((value, index) => value === version(right)[index]);
+
+/** Materialize a finite trace, keeping links deferred until all file writes settle. */
+export async function copyStandaloneTrace(files, {tracingRoot, relocate, maxFiles, maxBytes, concurrency = 8}, io = {lstat, realpath, mkdir, copyFile, stat}) {
+  const sources = Array.from(files);
+  if (sources.length > maxFiles) throw new Error('Standalone output exceeds 100000 files / 2 GiB. Narrow tracing includes.');
+  // Metadata can overlap, but admission and destination ordering remain exactly
+  // the trace's order. No bytes are copied before the whole budget is admitted.
+  const metadata = await mapConcurrent(sources, async source => {
+    const info = await io.lstat(source);
+    if (info.isSymbolicLink()) return {source, info, destination: await io.realpath(source)};
+    return {source, info};
+  }, concurrency);
+  let copiedFiles = 0, copiedBytes = 0;
+  const pendingLinks = [], groups = new Map();
+  for (const {source, info, destination} of metadata) {
+    if (info.isSymbolicLink() && !within(tracingRoot, source) && within(destination, tracingRoot)) continue;
+    const target = relocate(source);
+    if (++copiedFiles > maxFiles || (copiedBytes += info.size) > maxBytes) throw new Error('Standalone output exceeds 100000 files / 2 GiB. Narrow tracing includes.');
+    if (info.isSymbolicLink()) { pendingLinks.push([target, relocate(destination)]); continue; }
+    if (!info.isFile()) continue;
+    const key = process.platform === 'win32' ? target.toLowerCase() : target;
+    if (!groups.has(key)) groups.set(key, []);
+    groups.get(key).push({source, target, info});
+  }
+  const directories = new Map();
+  await mapConcurrent(groups.values(), async entries => {
+    // Alias collisions retain the old serial last-writer order. Unrelated files
+    // share a small I/O worker set and one mkdir promise per destination parent.
+    for (const {source, target, info} of entries) {
+      const before = await io.lstat(source);
+      if (!before.isFile() || !unchanged(info, before)) throw new Error('Standalone input changed before copying.');
+      const directory = path.dirname(target);
+      if (!directories.has(directory)) directories.set(directory, io.mkdir(directory, {recursive: true}));
+      await directories.get(directory);
+      await io.copyFile(source, target);
+      const [after, copied] = await Promise.all([io.lstat(source), io.stat(target)]);
+      if (!after.isFile() || !unchanged(before, after) || !copied.isFile() || copied.size !== before.size) throw new Error('Standalone input changed while copying.');
+    }
+  }, concurrency);
+  return {copiedFiles, copiedBytes, pendingLinks};
+}

package/build/standalone.mjs

@@ -7,6 +7,7 @@ import path from 'node:path';
 import { resolveNativeBinary } from '../native/resolve.mjs';
 import { createHash } from 'node:crypto';
 import { createRequire } from 'node:module';
+import {copyStandaloneTrace} from './standalone-copy.mjs';
 
 const slash = value => value.split(path.sep).join('/');
 const within = (root, file) => file === root || file.startsWith(root + path.sep);
@@ -219,28 +220,7 @@ export async function createStandalone({ projectRoot, stage, manifest, config })
     } else traceFiles.add(target);
   }
   await mkdir(output, { recursive: true });
-  let copiedBytes = 0;
-  let copiedFiles = 0;
-  const pendingLinks = [];
-  for (const source of traceFiles) {
-    const info = await lstat(source);
-    // NFT also emits ancestor aliases used by absolute workspace links, such as
-    // macOS /var -> /private/var. Their canonical children are already traced;
-    // these host directory aliases are not dependencies of the artifact.
-    // Real files and links to unrelated external workspaces still go through
-    // relocated(), which enforces the configured tracing boundary.
-    if (info.isSymbolicLink() && !within(tracingRoot, source) && within(await realpath(source), tracingRoot)) continue;
-    const target = relocated(source);
-    if (++copiedFiles > maxFiles || (copiedBytes += info.size) > maxBytes) throw new Error('Standalone output exceeds 100000 files / 2 GiB. Narrow tracing includes.');
-    if (info.isSymbolicLink()) {
-      const destination = await realpath(source);
-      pendingLinks.push([target, relocated(destination)]);
-      continue;
-    }
-    if (!info.isFile()) continue;
-    await mkdir(path.dirname(target), { recursive: true });
-    await copyFile(source, target);
-  }
+  let {copiedBytes, copiedFiles, pendingLinks} = await copyStandaloneTrace(traceFiles, {tracingRoot, relocate: relocated, maxFiles, maxBytes});
   const owners = new Set(bridges.values());
   const includedOwners = new Set();
   for (const file of traceFiles) for (let dir = path.dirname(file); dir !== path.dirname(dir); dir = path.dirname(dir)) if (owners.has(dir)) includedOwners.add(dir);

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-cache.mjs

@@ -25,7 +25,14 @@ export async function withPersistentTransforms(root,{enabled=true,dev=false}={},
   return result;
 }
 function identity(kind,source,settings){return createHash('sha256').update(persistent.getStore()?.key||'memory').update(JSON.stringify([kind,settings,sourceMapsEnabled()])).update('\0').update(source).digest('hex');}
-function diskValue(key){const scope=persistent.getStore();if(!scope?.values.has(key))return;const value=scope.values.get(key);scope.values.delete(key);scope.values.set(key,value);diskHits++;hits++;return value;}
+function discard(key){const value=entries.get(key);if(value){entries.delete(key);bytes-=value.size;}}
+function validValue(value,validate){if(!validate)return true;try{return validate(value)===true;}catch{return false;}}
+function diskValue(key,validate){
+  const scope=persistent.getStore();if(!scope?.values.has(key))return;
+  const value=scope.values.get(key);scope.values.delete(key);
+  if(!validValue(value,validate)){scope.bytes-=Buffer.byteLength(value);scope.dirty=true;return;}
+  scope.values.set(key,value);diskHits++;hits++;return value;
+}
 function remember(key,output){
   const scope=persistent.getStore();if(!scope||typeof output!=='string')return;
   const size=Buffer.byteLength(output);if(size>128*1024)return;
@@ -38,16 +45,23 @@ function remember(key,output){
 // closure or mutable build metadata survives in the cache. Include all options
 // affecting output in settings, including build identity and target mode.
 export function cachedTransform(kind, source, settings, transform) {
+  return cachedValidatedTransform(kind,source,settings,undefined,transform);
+}
+
+/** Typed compiler facts may replay only structurally validated string records. */
+export function cachedValidatedTransform(kind, source, settings, validate, transform) {
   const key = identity(kind,source,settings);
   const found = entries.get(key);
-  if (found) {
+  if (found && validValue(found.output,validate)) {
     hits++; entries.delete(key); entries.set(key,found);
     if(persistent.getStore()&&!persistent.getStore().values.has(key))remember(key,found.output);
     return found.output;
   }
-  const saved=diskValue(key);if(saved!==undefined)return saved;
+  if(found)discard(key);
+  const saved=diskValue(key,validate);if(saved!==undefined)return saved;
   misses++;
   const output = transform();
+  if(!validValue(output,validate))throw new TypeError('Invalid typed compiler cache result');
   remember(key,output);
   // UTF-16 is an upper bound for the retained string payload. Metadata adds
   // engine overhead; the entry count also bounds that overhead.

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

@@ -22,6 +22,7 @@ Use prnext for portable scripts; prn is a shortcut on compatible shells.
                                        Detect a completed browser build
   prnext build [directory] --adapter static --from .
                                        Build a plain HTML/CSS/JS site
+  prnext build [directory] --timings    Show time spent in React build phases
   prnext output [directory] [--json]    Read the versioned build output contract
   prnext start [directory] [options]    Start native Rust production server
   prnext pstart [directory] [options]   Start production persistently in the background
@@ -38,12 +39,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 +113,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 +321,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;
@@ -331,11 +339,16 @@ async function main() {
   }
   if (command === 'build') {
     const options = {};
+    let showTimings = false;
     for (let i = 0; i < args.length; i++) {
       const flag = args[i];
       if (flag === '--dev') options.dev = true;
       else if (flag === '--watch') options.watch = true;
       else if (flag === '--spa') options.spa = true;
+      else if (flag === '--timings') {
+        if (showTimings) throw new Error('Duplicate build option: --timings');
+        showTimings = true;
+      }
       else if (flag === '--adapter' || flag === '--from') {
         const value = args[++i];
         if (!value || value.startsWith('-')) throw new Error(`${flag} requires a value`);
@@ -349,6 +362,7 @@ async function main() {
     process.env.NODE_ENV = dev ? 'development' : 'production';
     const started = performance.now();
     if(options.watch){
+      if(showTimings)throw new Error('--timings reports one build. Run prnext build --timings without --watch.');
       if(dev)throw new Error('--watch builds production; use prnext dev for development.');
       const {watchProduction}=await import('./build/production-builder.mjs');
       delete options.watch;await watchProduction(root,options);return;
@@ -360,11 +374,17 @@ async function main() {
       else if (options.adapter === 'auto') options.adapter = 'react';
     }
     if (options.adapter === 'static') {
+      if(showTimings)throw new Error('--timings requires the React build adapter.');
       const { buildStatic } = await import('./build/static-adapter.mjs');
       await buildStatic(root, options);
     } else {
       const { build } = await import('./build/index.mjs');
       const result=await build(root, { ...options, dev, envMode });
+      if(showTimings&&result.buildTimings){
+        console.log('Build timings (milliseconds; nested phases are not additive):');
+        for(const[name,phase]of Object.entries(result.buildTimings.phases))console.log(`  ${name}: ${phase.milliseconds.toFixed(2)} (${phase.calls} ${phase.calls===1?'call':'calls'})`);
+        console.log(`  total: ${result.buildTimings.totalMilliseconds.toFixed(2)} (excludes CLI module startup)`);
+      }
       if(!dev&&result.compilationCache?.hits){
         const {hits,reusedBytes}=result.compilationCache;
         console.log(`Compilation cache: ${hits} ${hits===1?'graph':'graphs'} reused (${Math.ceil(reusedBytes/1024)} KiB).`);
@@ -380,7 +400,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/diagnostics.cjs

@@ -4,10 +4,11 @@ const directory = process.env.PRNEXT_INSPECT_DIR;
 const { threadId } = require('node:worker_threads');
 let queue = [], scheduled = false, writing = false, size;
 const limit = 1024 * 1024;
-if (directory) setInterval(() => {
-  const {rss, heapUsed} = process.memoryUsage();
-  record('process', {rssBytes:rss, heapUsedBytes:heapUsed});
-}, 5000).unref();
+if (directory) {
+  // No GC observer or periodic sampler exists when diagnostics are disabled.
+  const sampler = require('./runtime-sample.cjs').createRuntimeSampler();
+  setInterval(() => record('process', sampler.sample()), 5000).unref();
+}
 function record(type, fields = {}) {
   if (!directory || queue.length >= 256) return;
   const line = JSON.stringify({ time: Date.now(), pid: process.pid, type, ...fields }) + '\n';