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

package/build/styles.mjs

@@ -39,10 +39,12 @@ async function loadConfiguration(root) {
   return /\.(?:js|mjs|cjs)$/.test(filename) ? importConfiguration(filename) : JSON.parse(await readFile(filename, 'utf8'));
 }
 
-async function createProcessor(root, engine) {
+export const resolveStandardBrowserTargets = root => browserslist(undefined,{path:path.resolve(root)});
+
+async function createProcessor(root, engine, browserTargets) {
   const config = await loadConfiguration(root);
   if (config === undefined && engine !== 'postcss') {
-    const targets=browserslistToTargets(browserslist(undefined,{path:root}));
+    const targets=browserslistToTargets(browserTargets ? await browserTargets() : resolveStandardBrowserTargets(root));
     return {async process(css,options){
       const result=transformCss({filename:options.from,code:Buffer.from(css),targets,minify:false,sourceMap:!!options.map,
         ...(options.map?.prev ? {inputSourceMap:JSON.stringify(options.map.prev)} : {}),drafts:{customMedia:true}});
@@ -134,7 +136,7 @@ function packageImporter(require) {
 }
 
 /** Build-only transformations, shared and deduplicated across all three React graphs. */
-export function createStyleProcessor({ projectRoot, sassOptions = {}, cssEngine = 'auto' }) {
+export function createStyleProcessor({ projectRoot, sassOptions = {}, cssEngine = 'auto', browserTargets }) {
   const root = path.resolve(projectRoot);
   const require = createRequire(path.join(root, 'package.json'));
   const cache = new Map();
@@ -168,7 +170,7 @@ export function createStyleProcessor({ projectRoot, sassOptions = {}, cssEngine
       sourceMap = compiled.sourceMap;
       for (const url of compiled.loadedUrls) if (url.protocol === 'file:') dependencies.add(fileURLToPath(url));
     }
-    processor ??= createProcessor(root,cssEngine);
+    processor ??= createProcessor(root,cssEngine,browserTargets);
     const processed = await (await processor).process(css, { from: file, to: file, map: sourceMap ? { prev: sourceMap, inline: false, annotation: false } : false });
     for (const message of processed.messages) if (message.type === 'dependency' && message.file) dependencies.add(path.resolve(root, message.file));
     rebaseReferences(processed.root, file);

package/build/transform.mjs

@@ -51,7 +51,7 @@ export async function rewriteServerChunks(file,chunks,publicPath){
 }
 
 function parserOptions(filename) {
-  return { sourceType: 'unambiguous', sourceFilename: filename, plugins: ['jsx', ...( /\.tsx?$/.test(filename) ? ['typescript'] : [])] };
+  return { sourceType: 'unambiguous', sourceFilename: filename, plugins: ['jsx', ...( /\.[cm]?tsx?$/.test(filename) ? ['typescript'] : [])] };
 }
 
 export function assertSupportedSource(source, filename) {

package/build/typed-routes.mjs

@@ -3,6 +3,8 @@ import {createRequire} from 'node:module';
 import {randomUUID} from 'node:crypto';
 import path from 'node:path';
 import {fileURLToPath} from 'node:url';
+import {resolveTypeScript} from './typescript-toolchain.mjs';
+import {nativeTypeConfig} from './native-type-config.mjs';
 
 const marker='// Generated by PRNext: typed route registry. Do not edit.';
 async function changed(file,contents,updates){
@@ -52,6 +54,8 @@ async function bindTypes(filename,ts,updates){
 async function includeTypes(root,config,helper,updates){
   const filename=path.resolve(root,config.typescript?.tsconfigPath||'tsconfig.json');
   const source=await readFile(filename,'utf8').catch(error=>{if(error.code==='ENOENT')return;throw error;});if(source===undefined)return;
+  const toolchain=await resolveTypeScript(root);
+  if(toolchain.native){await changed(filename,await nativeTypeConfig(filename,helper),updates);return;}
   let ts;try{ts=createRequire(path.join(root,'package.json'))('typescript');}catch{throw Error('typedRoutes requires TypeScript installed in the application');}
   const parsed=ts.getParsedCommandLineOfConfigFile(filename,{noEmit:true},{...ts.sys,onUnRecoverableConfigFileDiagnostic:diagnostic=>{throw Error(ts.flattenDiagnosticMessageText(diagnostic.messageText,'\n'));}});
   if(!parsed||parsed.errors.some(error=>error.code!==18003))throw Error('Cannot configure typed routes: invalid tsconfig');

package/build/typescript-dev.mjs

@@ -1,22 +1,49 @@
 import {fork} from 'node:child_process';
 import {access} from 'node:fs/promises';
-import {createRequire} from 'node:module';
+import {resolveTypeScript} from './typescript-toolchain.mjs';
 import path from 'node:path';
 import {privateCacheDirectory} from './persistent-cache.mjs';
-export async function startTypeChecker(root,config,notify){
+export async function startTypeChecker(root,config,notify,{fork:spawnChecker=fork,recheckDelayMs=3000}={}){
   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;}
-  let compiler;try{compiler=createRequire(path.join(root,'package.json')).resolve('typescript');}catch{console.warn('TypeScript diagnostics require typescript installed in the application.');return noop;}
+  let toolchain;try{toolchain=await resolveTypeScript(root);}catch(error){console.warn('TypeScript diagnostics could not start: '+error.message);return noop;}
   const directory=await privateCacheDirectory(root,'typescript-dev');
-  let child,closed=false,failures=0,timer;
+  let child,closed=false,failures=0,timer,restartTimer,planned,pendingInvalidation;
   function launch(){
     if(closed)return;
-    child=fork(new URL('./typescript-dev-worker.mjs',import.meta.url),[compiler,filename,directory?path.join(directory,'project.tsbuildinfo'):''],{cwd:root,execArgv:['--max-old-space-size=512'],stdio:['ignore','ignore','pipe','ipc'],windowsHide:true});
+    const worker=toolchain.native?'./typescript-native-worker.mjs':'./typescript-dev-worker.mjs';
+    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});
+    const current=child;
     let details='',healthyAt=0;child.stderr.on('data',chunk=>{details=(details+chunk).slice(-2048);});
-    child.on('message',message=>{if(message?.type==='diagnostics'&&Array.isArray(message.errors)){healthyAt ||= Date.now();notify(message.errors.filter(value=>typeof value==='string').slice(0,40));}});
+    child.on('message',message=>{
+      if(closed||child!==current||planned===current)return;
+      if(message?.type==='diagnostics'&&Array.isArray(message.errors)){
+        // The native watcher normally handles edits incrementally. Its startup
+        // can miss an edit; retain one bounded fallback when no report arrives.
+        if(pendingInvalidation?.worker===current&&!pendingInvalidation.forced){clearTimeout(restartTimer);pendingInvalidation=undefined;}
+        healthyAt ||= Date.now();notify(message.errors.filter(value=>typeof value==='string').slice(0,40));
+      }
+    });
     child.on('error',error=>{notify(['TypeScript checker: '+error.message]);});
-    child.once('exit',()=>{if(closed)return;if(healthyAt&&Date.now()-healthyAt>=60000)failures=0;if(++failures>=3){notify(['TypeScript checker stopped after repeated failures. '+details]);return;}timer=setTimeout(launch,1000*failures);});
+    child.once('exit',()=>{
+      if(pendingInvalidation?.worker===current){clearTimeout(restartTimer);pendingInvalidation=undefined;}
+      if(closed)return;if(planned===current){planned=undefined;launch();return;}if(healthyAt&&Date.now()-healthyAt>=60000)failures=0;if(++failures>=3){notify(['TypeScript checker stopped after repeated failures. '+details]);return;}timer=setTimeout(launch,1000*failures);
+    });
   }
-  launch();return {async close(){closed=true;clearTimeout(timer);const old=child;if(!old||old.exitCode!==null||old.signalCode)return;await new Promise(resolve=>{const timer=setTimeout(()=>old.kill('SIGKILL'),3000);old.once('exit',()=>{clearTimeout(timer);resolve();});if(old.connected)old.disconnect();else old.kill();});}};
+  launch();return {
+    invalidate(file,event){
+      if(!toolchain.native||closed||!child?.connected)return;
+      const extension=path.extname(file);if(extension&&!/^\.(?:[cm]?[jt]sx?|json)$/i.test(extension))return;
+      const forced=event==='rename'||/\.json$/i.test(file);
+      if(!forced&&event!=='change')return;
+      clearTimeout(restartTimer);
+      const pending={worker:child,forced:forced||pendingInvalidation?.forced===true};pendingInvalidation=pending;
+      restartTimer=setTimeout(()=>{
+        if(closed||pendingInvalidation!==pending||child!==pending.worker||!child?.connected)return;
+        pendingInvalidation=undefined;planned=child;child.disconnect();
+      },pending.forced?150:recheckDelayMs);
+    },
+    async close(){closed=true;clearTimeout(timer);clearTimeout(restartTimer);const old=child;if(!old||old.exitCode!==null||old.signalCode)return;await new Promise(resolve=>{const timer=setTimeout(()=>old.kill('SIGKILL'),5000);old.once('exit',()=>{clearTimeout(timer);resolve();});if(old.connected)old.disconnect();else old.kill();});},
+  };
 }

package/build/typescript-native-worker.mjs

@@ -0,0 +1,55 @@
+import {spawn} from 'node:child_process';
+import {StringDecoder} from 'node:string_decoder';
+import {mkdtemp,rm} from 'node:fs/promises';
+import {tmpdir} from 'node:os';
+import path from 'node:path';
+
+const [compiler,filename,mode]=process.argv.slice(2);
+const watching=mode==='watch';
+let closing=false,buffer='',output='',overflow=false;
+const cache=await mkdtemp(path.join(tmpdir(),'prnext-typescript-native-'));
+const child=spawn(process.execPath,[compiler,'--project',filename,'--noEmit','--incremental','true','--tsBuildInfoFile',path.join(cache,'project.tsbuildinfo'),'--pretty','false','--locale','en',...(watching?['--watch','--preserveWatchOutput']:[])],{
+  cwd:process.cwd(),windowsHide:true,detached:process.platform!=='win32',stdio:['ignore','pipe','pipe'],
+  // Native TS respects explicit project watch options. The polling defaults
+  // also cover editors/filesystems that silently lose native watch events.
+  env:{...process.env,TSC_WATCHFILE:process.env.TSC_WATCHFILE||'DynamicPriorityPolling',TSC_WATCHDIRECTORY:process.env.TSC_WATCHDIRECTORY||'DynamicPriorityPolling'},
+});
+function send(value){if(process.connected)process.send(value);}
+function consume(chunk){
+  const text=chunk.toString('utf8').replace(/\x1b\[[0-9;]*[A-Za-z]/g,'');
+  if(!watching){output+=text;if(output.length>4*1024*1024){overflow=true;void close();}return;}
+  buffer+=text;
+  // Consume complete lines, not arbitrary OS chunks. Start/completion markers
+  // delimit each diagnostic generation; a successful edit clears old errors.
+  let end;
+  while((end=buffer.indexOf('\n'))!==-1){
+    const line=buffer.slice(0,end).replace(/\r$/,'');buffer=buffer.slice(end+1);
+    if(/Starting (?:incremental )?compilation in watch mode|File change detected/.test(line))output='';
+    else if(/Found \d+ errors?\. Watching for file changes\./.test(line)){
+      send({type:'diagnostics',errors:/Found 0 errors/.test(line)?[]:output.trim()?[output.trim()]:['TypeScript reported errors. Run prnext typecheck for details.']});output='';
+    }else if(line.trim()&&output.length<20000)output+=(line+'\n').slice(0,20000-output.length);
+  }
+  if(buffer.length>20000)buffer=buffer.slice(-20000);
+}
+for(const stream of [child.stdout,child.stderr]){
+  const decoder=new StringDecoder('utf8');stream.on('data',chunk=>consume(decoder.write(chunk)));stream.on('end',()=>consume(decoder.end()));
+}
+child.once('error',error=>{send({type:'failure',message:error.message});process.exitCode=1;});
+child.once('close',async(code,signal)=>{
+  // Only the directory returned by mkdtemp above is removed.
+  if(path.dirname(cache)===path.resolve(tmpdir())&&path.basename(cache).startsWith('prnext-typescript-native-'))await rm(cache,{recursive:true,force:true,maxRetries:5,retryDelay:100});
+  send({type:'complete',code:overflow?1:code??1,output:overflow?'TypeScript output exceeded 4 MiB. Run tsc directly for the complete output.':output,signal});
+  if(process.connected)process.disconnect();
+});
+async function close(){
+  if(closing)return;closing=true;
+  if(child.exitCode!==null||child.signalCode)return;
+  if(process.platform==='win32'){
+    // Own exactly this compiler subtree; TypeScript's official Node launcher
+    // starts its native executable as a child on Windows.
+    const killer=spawn('taskkill',['/PID',String(child.pid),'/T','/F'],{windowsHide:true,stdio:'ignore'});
+    killer.on('error',()=>child.kill('SIGKILL'));
+  }else{try{process.kill(-child.pid,'SIGTERM');}catch{child.kill('SIGTERM');}}
+}
+process.once('disconnect',()=>{void close();});
+process.once('SIGTERM',()=>{void close();});process.once('SIGINT',()=>{void close();});

package/build/typescript-native.mjs

@@ -0,0 +1,18 @@
+import {fork} from 'node:child_process';
+
+export function checkNativeTypeScript(compiler,filename,root){
+  return new Promise((resolve,reject)=>{
+    const child=fork(new URL('./typescript-native-worker.mjs',import.meta.url),[compiler,filename,'check'],{cwd:root,windowsHide:true,execArgv:[],stdio:['ignore','ignore','pipe','ipc']});
+    let result,details='',timedOut=false,force;
+    const deadline=setTimeout(()=>{timedOut=true;if(child.connected)child.disconnect();force=setTimeout(()=>child.kill('SIGKILL'),5000);},120000);
+    child.stderr.on('data',chunk=>{details=(details+chunk).slice(-8192);});
+    child.on('message',message=>{if(message?.type==='complete')result=message;else if(message?.type==='failure')details=String(message.message).slice(0,8192);});
+    child.once('error',error=>{clearTimeout(deadline);clearTimeout(force);reject(error);});
+    child.once('exit',()=>{
+      clearTimeout(deadline);clearTimeout(force);
+      if(timedOut)reject(new Error('TypeScript check exceeded 120 seconds. Run tsc directly to inspect the project.'));
+      else if(result?.code===0)resolve();
+      else reject(new Error(result?.output||details||'TypeScript native checker exited before returning diagnostics.'));
+    });
+  });
+}

package/build/typescript-toolchain.mjs

@@ -0,0 +1,19 @@
+import {readFile,stat} from 'node:fs/promises';
+import {createRequire} from 'node:module';
+import path from 'node:path';
+
+// Select from the application's installation, never from the framework's own
+// development dependencies. Native TypeScript deliberately lacks the old API.
+export async function resolveTypeScript(root) {
+  const require=createRequire(path.join(root,'package.json'));
+  const manifest=require.resolve('typescript/package.json');
+  const metadata=JSON.parse(await readFile(manifest,'utf8'));
+  const major=Number(/^([0-9]+)\./.exec(metadata.version)?.[1]);
+  if(!Number.isInteger(major))throw new Error('The installed TypeScript package has no valid version.');
+  if(major<7)return {native:false,compiler:require.resolve('typescript'),version:metadata.version};
+  const entry=typeof metadata.bin==='string'?metadata.bin:metadata.bin?.tsc;
+  if(typeof entry!=='string'||!entry)throw new Error('The installed TypeScript package has no tsc command. Reinstall TypeScript with its optional native dependencies.');
+  const directory=path.dirname(manifest),bin=path.resolve(directory,entry);
+  if(!bin.startsWith(directory+path.sep)||!(await stat(bin)).isFile())throw new Error('The installed TypeScript tsc command is invalid.');
+  return {native:true,compiler:bin,version:metadata.version};
+}

package/build/typescript.mjs

@@ -1,9 +1,10 @@
 import { stat } from 'node:fs/promises';
-import { createRequire } from 'node:module';
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
 import { fileURLToPath } from 'node:url';
 import path from 'node:path';
+import {resolveTypeScript} from './typescript-toolchain.mjs';
+import {checkNativeTypeScript} from './typescript-native.mjs';
 
 const execute = promisify(execFile);
 
@@ -37,11 +38,12 @@ export async function checkTypeScript(root, config, { dev = false, tsconfig, for
   if (!force && (dev || !config.typescript || config.typescript.ignoreBuildErrors)) return;
   tsconfig ??= await projectTsconfig(root, config);
   if (!tsconfig) throw new Error('TypeScript checking was explicitly enabled, but tsconfig.json does not exist. Create a TypeScript configuration, set typescript.tsconfigPath to an existing configuration, or explicitly set typescript.ignoreBuildErrors: true if types are checked separately.');
-  let compiler;
-  try { compiler = createRequire(path.join(root, 'package.json')).resolve('typescript'); }
+  let toolchain;
+  try { toolchain = await resolveTypeScript(root); }
   catch (error) { throw new Error('TypeScript checking requires typescript in the project. Install it as a dev dependency, or explicitly set typescript.ignoreBuildErrors: true if a separate process checks types.', { cause: error }); }
   try {
-    await execute(process.execPath, [fileURLToPath(new URL('./typescript-check.mjs', import.meta.url)), compiler, tsconfig], {
+    if(toolchain.native){await checkNativeTypeScript(toolchain.compiler,tsconfig,root);return;}
+    await execute(process.execPath, [fileURLToPath(new URL('./typescript-check.mjs', import.meta.url)), toolchain.compiler, tsconfig], {
       cwd: root, windowsHide: true, maxBuffer: 4 * 1024 * 1024,
     });
   } catch (error) {

package/build/webpack-graph.mjs

@@ -77,6 +77,13 @@ function pluginIdentity(plugin,webpack){
 export const webpackCompilerStats=()=>({contexts:sessions.size,created,reused,limit:sessionLimit,buildLimit:sessionBuildLimit});
 function queued(callback){const task=graphQueue.then(callback);graphQueue=task.catch(()=>{});return task;}
 export function closeWebpackCompiler(root){return queued(async()=>{
+  if(root!==undefined){
+    try{root=await realpath(root);}
+    catch(error){
+      if(error.code!=='ENOENT'&&error.code!=='ENOTDIR')throw error;
+      root=path.resolve(root);
+    }
+  }
   const closing=[];for(const[key,session]of sessions)if(root===undefined||session.root===root){sessions.delete(key);closing.push(session.dispose());}
   const results=await Promise.allSettled(closing),errors=results.filter(result=>result.status==='rejected').map(result=>result.reason);
   if(errors.length)throw new AggregateError(errors,'Unable to dispose webpack compiler sessions');
@@ -84,6 +91,9 @@ export function closeWebpackCompiler(root){return queued(async()=>{
 
 async function compileGraph(resolver,loads,options,{state,config,target}){
   return queued(async()=>{
+    // Ownership uses one canonical identity for invalidation and disposal.
+    // Compiler paths and graph fingerprints retain the caller's lexical root.
+    const ownerRoot=await realpath(state.root);
     const webpack=(await import('webpack')).default;
     let reusable=state.dev&&state.incremental,identity;
     if(reusable){try{identity=await buildCacheIdentity(state.root);}catch{}if(!identity)reusable=false;}
@@ -97,17 +107,17 @@ async function compileGraph(resolver,loads,options,{state,config,target}){
     // Unknown data structures, safe mode and unavailable identities all keep
     // compilation correct through a one-shot compiler. Hidden mutable closure
     // state cannot be fingerprinted: replace the plugin instance when it changes.
-    if(state.dev&&!reusable)for(const[key,session]of sessions)if(session.root===state.root){sessions.delete(key);await session.dispose();}
+    if(state.dev&&!reusable)for(const[key,session]of sessions)if(session.root===ownerRoot){sessions.delete(key);await session.dispose();}
     let session=reusable&&sessions.get(key);
     if(session&&session.builds>=sessionBuildLimit){sessions.delete(key);await session.dispose();session=undefined;}
     if(reusable){
-      for(const[old,previous]of sessions)if(previous.root===state.root&&(previous.identity!==identity||previous.base===base&&old!==key)){sessions.delete(old);await previous.dispose();}
+      for(const[old,previous]of sessions)if(previous.root===ownerRoot&&(previous.identity!==identity||previous.base===base&&old!==key)){sessions.delete(old);await previous.dispose();}
     }
     if(session){sessions.delete(key);reused++;}
     else{
       if(reusable)while(sessions.size>=sessionLimit){const[old,previous]=sessions.entries().next().value;sessions.delete(old);await previous.dispose();}
       session=await createGraphSession(state.root,{webpack,reusable,stage:state.stage});created++;
-      Object.assign(session,{root:state.root,base,identity,builds:0});
+      Object.assign(session,{root:ownerRoot,base,identity,builds:0});
     }
     if(reusable)sessions.set(key,session);
     try{session.builds++;return await session.run(resolver,loads,options,{state,config,target});}
@@ -233,7 +243,7 @@ async function createGraphSession(root,{webpack,reusable,stage}) {
         cssChunkFilename:'style-[contenthash:16].css',module:true,library:{type:'module'},chunkFormat:'module',chunkLoading:'import',
         publicPath:target==='node'?'./':state.assetBase+'/',environment:{module:true,dynamicImport:true},compareBeforeEmit:false,clean:false},
       performance:false,
-      optimization:{minimize:!!options.minify,minimizer:[{apply(compiler){
+      optimization:{minimize:!!options.minify,mangleExports:options.minify?'size':false,minimizer:[{apply(compiler){
         compiler.hooks.compilation.tap('PRNextMinify',compilation=>{
           compilation.hooks.processAssets.tapPromise({name:'PRNextMinify',stage:webpack.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_SIZE},async()=>{
             // Sequential native esbuild transforms avoid a Terser worker pool.
@@ -247,7 +257,7 @@ async function createGraphSession(root,{webpack,reusable,stage}) {
           });
         });
       }}],runtimeChunk:options.splitting?{name:()=>runtime}:false,
-        splitChunks:options.splitting?{chunks:'all',minSize:0,cacheGroups:{default:false,defaultVendors:false,shared:{minChunks:2,test:module=>!module.type.startsWith('css'),name:false}}}:false},
+        splitChunks:options.splitting?{chunks:'all',minSize:0,cacheGroups:{default:false,defaultVendors:false,shared:{minChunks:2,reuseExistingChunk:true,test:module=>!module.type.startsWith('css'),name:false}}}:false},
       resolve:{alias:config.resolution.resolveAlias || {},conditionNames:[...(options.conditions || []),'...'],extensions:config.resolution.resolveExtensions || ['.tsx','.ts','.jsx','.js','.mjs','.json'],fullySpecified:false},
       module:{unsafeCache:false,rules:[{test:/./,type:'javascript/auto',enforce:'post',use:[{loader:loaderPath,options:{bridge:bridgeId}}]},
         {test:/\.json$/,type:'json'},{test:/\.(?:css|scss|sass)$/,type:'css'},
@@ -379,7 +389,10 @@ async function createGraphSession(root,{webpack,reusable,stage}) {
       for(const name of previousOutputs)if(!currentOutputs.has(name))await discardPrivateFile(path.join(actualOut,name),actualOut);
       previousOutputs.clear();for(const name of currentOutputs)previousOutputs.add(name);
     }
-    return {errors:[],warnings:[],metafile:{inputs,outputs},...(options.write===false?{outputFiles}:{})};
+    // This compatibility metafile does not yet encode webpack's runtime and
+    // async chunk-group edges. Consumers must not mistake empty import lists
+    // for a complete initial browser graph.
+    return {errors:[],warnings:[],metafile:{inputs,outputs,initialGraphComplete:false},...(options.write===false?{outputFiles}:{})};
   } finally {
     active.delete(bridgeId);
     for(const file of virtualFiles)if(!usedVirtualFiles.has(file)){virtualFiles.delete(file);await discardPrivateFile(file,home);}

package/build/worker-memory.mjs

@@ -0,0 +1,9 @@
+export function validateWorkerMemory(value) {
+  if (value === undefined || value === false) return undefined;
+  if (!value || typeof value !== 'object' || Array.isArray(value) ||
+      Object.keys(value).some(key => key !== 'maxRssMb') ||
+      !Number.isSafeInteger(value.maxRssMb) || value.maxRssMb < 64 || value.maxRssMb > 65536) {
+    throw new TypeError('workerMemory must be false or { maxRssMb: 64..65536 }');
+  }
+  return { maxRssMb: value.maxRssMb };
+}

package/cli.mjs

@@ -11,6 +11,9 @@ const help = `PRNext ${packageManifest.version}
 
 Use prnext for portable scripts; prn is a shortcut on compatible shells.
 
+  prnext create <directory>            Create a project and install dependencies
+  prnext create <directory> --no-install  Prepare project files without installing
+  prnext create --help                 TypeScript, JavaScript and creation options
   prnext build [directory]              Build React/TypeScript and static HTML
   prnext build [directory] --watch      Incremental production rebuilds on changes
   prnext build [directory] --adapter static [--from dist] [--spa]
@@ -40,6 +43,7 @@ Use prnext for portable scripts; prn is a shortcut on compatible shells.
   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 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
@@ -54,6 +58,8 @@ Migration options: --dry-run (preview), --no-install (prepare only), --json
   prnext migrate --check                Audit source compatibility without migrating
   prnext migrate --check --against URL --candidate URL [--routes paths.json]
                                        Compare GET responses before switching
+  prnext migrate --check --against URL --candidate URL --browser-scenarios ./scenarios.mjs
+                                       Run trusted application browser assertions
 Migration keeps Next.js and backs up package.json and existing lockfiles.
 Simple next dev/build/start scripts become prnext commands; custom shell scripts need a manual edit.
 Installation honors npm, pnpm, Yarn Classic/Berry and the workspace root.
@@ -69,10 +75,12 @@ Analysis options: --metric raw|gzip|brotli (default raw), --baseline analysis.js
   --max-increase-bytes 1024 --max-increase-percent 5
   --budgets budgets.json               Exact route keys with maxJs (kB),
                                        maxIncreaseBytes and/or maxIncreasePercent
-Analysis exit codes: 0 passed, 1 budget exceeded, 2 invalid input or missing build.
+Analysis exit codes: 0 passed, 1 budget exceeded or initial total unverifiable,
+  2 invalid input or missing build. Request-dependent totals are lower bounds.
 
 Server options: --port 3000 --hostname 127.0.0.1 --workers 1 --inspect
 Production profiles: --profile balanced|speed|memory|classic
+Render readiness: --prewarm --readiness-file /private/path/ready.json
 Worker retirement: --worker-idle-seconds 300 --lane-idle-seconds 30 --keep-warm [true|false]
 Memory favors lower RAM under concurrency, accepting more waiting and CPU per response.
 Without an option: PRNEXT_PROFILE, legacy PRNEXT_MEMORY_PROFILE=compact, then balanced.
@@ -101,6 +109,30 @@ 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 === 'create') {
+    const { createHelp, parseCreateArgs, createProject } = await import('./build/create.mjs');
+    if (argv.length === 1 && ['--help', '-h'].includes(argv[0])) { console.log(createHelp); return; }
+    const { directory, options } = parseCreateArgs(argv);
+    const controller = new AbortController();
+    let interrupted;
+    const interrupt = signal => { interrupted = signal; controller.abort(); };
+    const onInt = () => interrupt('SIGINT'), onTerm = () => interrupt('SIGTERM');
+    process.on('SIGINT', onInt); process.on('SIGTERM', onTerm);
+    try {
+      const report = await createProject(directory, { ...options, signal: controller.signal,
+        onOutput: options.json ? () => {} : (chunk, stream) => process[stream].write(chunk) });
+      if (options.json) console.log(JSON.stringify(report, null, 2));
+      else {
+        console.log(`PRNext project ${report.status}: ${report.root}`);
+        if (report.error) console.error(report.error);
+        if (!report.ok) console.log('Project files were preserved. Retry installation from this directory.');
+        if (path.resolve(process.cwd()) !== directory) console.log(`\nOpen ${report.root} in your terminal, then run:`);
+        for (const next of report.next) console.log(`  ${next}`);
+      }
+      if (!report.ok) process.exitCode = interrupted === 'SIGINT' ? 130 : interrupted === 'SIGTERM' ? 143 : 1;
+    } finally { process.removeListener('SIGINT', onInt); process.removeListener('SIGTERM', onTerm); }
+    return;
+  }
   if (command === 'docs') {
     const { executeAiDocs } = await import('./runtime/ai-docs.mjs');
     const result = await executeAiDocs(argv);
@@ -161,13 +193,20 @@ async function main() {
         report.comparison = await compareServers({ ...options, routes });
         report.ok &&= report.comparison.ok;
       }
+      if (options.browserScenarios) {
+        const { runMigrationScenarios } = await import('./build/migration-scenarios.mjs');
+        report.browser = await runMigrationScenarios({ directory, ...options, scenarios: options.browserScenarios });
+        report.ok &&= report.browser.ok;
+      }
       if (options.json) console.log(JSON.stringify(report, null, 2));
       else {
         console.log(`PRNext migration check ${report.ok ? 'passed' : 'failed'}: ${directory}`);
         console.log(`${report.files} source files; ${report.routes.length} routes.`);
         for (const item of report.findings) console.log(`${item.severity.toUpperCase()} ${item.file || 'project'}${item.line ? ':' + item.line : ''}: ${item.message}\n  ${item.action}`);
         for (const result of report.comparison?.results || []) console.log(`${result.equal ? 'MATCH' : 'DIFFERENT'} ${result.route}: ${result.error || result.differences.join(', ') || 'responses match'}`);
-        for (const note of [...report.notes, ...(report.comparison ? [report.comparison.scope] : [])]) console.log(note);
+        for (const result of report.browser?.results || []) console.log(`BROWSER ${result.scenario} (${result.target}): ${result.status}${result.reason ? ' — ' + result.reason : ''}`);
+        if (report.browser?.reason) console.log(`BROWSER unknown: ${report.browser.reason}`);
+        for (const note of [...report.notes, ...(report.comparison ? [report.comparison.scope] : []), ...(report.browser ? [report.browser.scope] : [])]) console.log(note);
       }
       if (!report.ok) process.exitCode = 1;
       return;
@@ -185,10 +224,28 @@ async function main() {
     if (!report.ok) process.exitCode = 1;
     return;
   }
-  if (!['build', 'start', 'dev', 'routes', 'check', 'typegen', 'typecheck', 'inspect', 'analyze', 'output'].includes(command)) throw new Error(`Unknown command: ${command}\n${help}`);
+  if (!['build', 'start', 'dev', 'routes', 'check', 'typegen', 'typecheck', 'inspect', 'analyze', 'compiler', 'output'].includes(command)) throw new Error(`Unknown command: ${command}\n${help}`);
   const args = [...argv];
   const root = path.resolve(args[0] && !args[0].startsWith('-') ? args.shift() : '.');
-  if (['check','typegen','typecheck','analyze'].includes(command) && args.some(arg => ['--help','-h'].includes(arg))) { console.log(help); return; }
+  if (['check','typegen','typecheck','analyze','compiler'].includes(command) && args.some(arg => ['--help','-h'].includes(arg))) { console.log(help); return; }
+  if(command==='compiler'){
+    try {
+      if(args.some(arg=>arg!=='--json') || args.filter(arg=>arg==='--json').length>1)throw new Error('compiler accepts only [directory] and --json');
+      const {readReactCompilerReport,printReactCompilerReport}=await import('./build/react-compiler-report.mjs');
+      const {readBuildOutput}=await import('./build/output-contract.mjs');
+      const directory=path.join(root,await readBuildDirectory(root));
+      const output=await readBuildOutput(directory);
+      if(output.adapter!=='react')throw new Error('React Compiler reports apply to React builds. This application uses the static adapter.');
+      const report=await readReactCompilerReport(directory,{buildId:output.buildId});
+      if(!report)throw new Error('No React Compiler report is available. Rebuild this application with the installed PRNext version.');
+      if(args.includes('--json'))console.log(JSON.stringify(report,null,2));else printReactCompilerReport(report,{details:true});
+    } catch(error) {
+      if(args.includes('--json'))console.log(JSON.stringify({ok:false,error:error.message}));
+      else console.error(`PRNext compiler: ${error.message}`);
+      process.exitCode=2;
+    }
+    return;
+  }
   if(command==='analyze'){
     try {
       const {analyzeBuild,printAnalysis,parseAnalysisArgs}=await import('./build/analyze.mjs');
@@ -307,7 +364,15 @@ async function main() {
       await buildStatic(root, options);
     } else {
       const { build } = await import('./build/index.mjs');
-      await build(root, { ...options, dev, envMode });
+      const result=await build(root, { ...options, dev, envMode });
+      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).`);
+      }
+      if(result.reactCompilerReport?.enabled){
+        const {printReactCompilerReport}=await import('./build/react-compiler-report.mjs');
+        printReactCompilerReport(result.reactCompilerReport,{details:false});
+      }
     }
     console.log(`PRNext built ${root} in ${((performance.now() - started) / 1000).toFixed(2)}s`);
     return;

package/compat/activity-cache.cjs

@@ -0,0 +1,26 @@
+'use strict';
+
+// A shared budget across layout slots, rather than a separate page budget at
+// every nesting level. Only inactive branches enter this registry.
+function createActivityCache({ limit = 4, ttl = 120000, now = Date.now, schedule = setTimeout, cancel = clearTimeout } = {}) {
+  const entries = new Map(); let timer;
+  function arm() {
+    cancel(timer); timer = undefined;
+    if (entries.size) {
+      timer = schedule(prune, Math.max(1, Math.min(...[...entries.values()].map(entry => entry.expires)) - now()));
+      timer?.unref?.();
+    }
+  }
+  function prune() {
+    for (const [key, entry] of entries) if (entry.expires <= now()) { entries.delete(key); entry.evict(); }
+    while (entries.size > limit) { const [key, entry] = entries.entries().next().value; entries.delete(key); entry.evict(); }
+    arm();
+  }
+  return {
+    retain(key, evict) { if (!entries.has(key)) entries.set(key, { evict, expires: now() + ttl }); prune(); },
+    release(key) { entries.delete(key); arm(); },
+    clear() { const previous = [...entries.values()]; entries.clear(); cancel(timer); timer = undefined; for (const entry of previous) entry.evict(); },
+    get size() { return entries.size; },
+  };
+}
+module.exports = { createActivityCache };

package/compat/after.cjs

@@ -4,11 +4,11 @@ const { AsyncLocalStorage } = require('node:async_hooks');
 function after(task) {
   const context = require('./headers.cjs').currentRequest();
   if (require('./data-cache.cjs').inCacheScope()) throw new Error('after() cannot be registered inside a cache scope');
-  if (!context.afterScope || !['route', 'action', 'after'].includes(context.phase)) throw new Error('after() currently requires a Node Route Handler or Server Action in PRNext. Server Component and Edge after() lifecycles are not implemented.');
+  if (!context.afterScope || !['route', 'action', 'render', 'after'].includes(context.phase)) throw new Error('after() requires a Node Server Component, Route Handler or Server Action. Edge after() is not implemented.');
   context.afterScope.add(task, context, AsyncLocalStorage.snapshot());
 }
 
-function createAfterScope({ signal, timeoutMs = 25000, onTimeout = () => {}, onComplete, report = error => console.error('[prnext] after() failed:', error?.stack || error) } = {}) {
+function createAfterScope({ signal, timeoutMs = 25000, onTimeout = () => {}, onComplete, onRegistered, report = error => console.error('[prnext] after() failed:', error?.stack || error) } = {}) {
   const queue = []; let count = 0, closed = false, finishing;
   const deadline = Date.now() + timeoutMs;
   const track = promise => signal?.[Symbol.for('prnext.request-work')]?.(promise, { timeoutMs: Math.max(1, deadline - Date.now()) });
@@ -18,6 +18,7 @@ function createAfterScope({ signal, timeoutMs = 25000, onTimeout = () => {}, onC
       if (closed) throw new Error('after() request has already completed');
       if (typeof task !== 'function' && (!task || typeof task.then !== 'function')) throw new TypeError('after() expects a callback or a Promise');
       if (++count > 128) throw new Error('after() exceeds 128 tasks per request');
+      if (count === 1) onRegistered?.();
       const pending = typeof task === 'function' ? null : observe(task);
       if (pending) track(pending);
       queue.push({ task: pending ? null : task, pending, context, run });
@@ -27,8 +28,9 @@ function createAfterScope({ signal, timeoutMs = 25000, onTimeout = () => {}, onC
         try {
           while (queue.length) {
             const item = queue.shift(), remaining = deadline - Date.now();
-            if (remaining <= 0) { const error = new Error('after() exceeded the request maxDuration'); report(error); onTimeout(error); break; }
+            if (remaining <= 0) { const error = new Error('after() exceeded the request maxDuration'); await item.run(()=>report(error)); onTimeout(error); break; }
             const abort = new AbortController();
+            item.context.afterRestricted ||= item.context.phase === 'render';
             item.context.cookies._mutable = false;
             item.context.phase = 'after';
             item.context.signal = abort.signal;
@@ -38,7 +40,7 @@ function createAfterScope({ signal, timeoutMs = 25000, onTimeout = () => {}, onC
             let timer;
             try {
               const outcome = await Promise.race([work, new Promise(resolve => { timer = setTimeout(() => { const error = new Error('after() exceeded the request maxDuration'); abort.abort(error); resolve({ error }); }, remaining); })]);
-              if ('error' in outcome) report(outcome.error);
+              if ('error' in outcome) await item.run(()=>report(outcome.error));
               if (abort.signal.aborted) { onTimeout(outcome.error); break; }
             } finally { clearTimeout(timer); item.context.cacheState.closed = true; await onComplete?.(item.context); }
           }

package/compat/app-dynamic.cjs

@@ -19,7 +19,18 @@ function dynamic(input, options) {
   if (!opts.ssr && typeof React.useEffect !== 'function') {
     throw new Error('ssr: false is not supported with next/dynamic in Server Components. Move it into a Client Component.');
   }
-  const Lazy = React.lazy(() => Promise.resolve().then(opts.loader).then(moduleOf));
+  let Lazy;
+  if(process.env.NODE_ENV==='development'&&typeof window!=='undefined'&&typeof opts.__prnextDevIdentity==='string'){
+    const registry=globalThis.__PRNEXT_DEV_DYNAMIC__||=new Map();
+    let entry=registry.get(opts.__prnextDevIdentity);
+    if(!entry||entry.failed){
+      entry={loader:opts.loader};
+      entry.lazy=React.lazy(()=>Promise.resolve().then(()=>entry.loader()).then(moduleOf,error=>{entry.failed=true;throw error;}));
+      if(registry.size>=2048)registry.delete(registry.keys().next().value);
+      registry.set(opts.__prnextDevIdentity,entry);
+    }else entry.loader=opts.loader;
+    Lazy=entry.lazy;
+  }else Lazy=React.lazy(() => Promise.resolve().then(opts.loader).then(moduleOf));
   function DynamicComponent(props) {
     const fallback = opts.loading ? React.createElement(opts.loading, { isLoading: true, pastDelay: true, error: null }) : null;
     const child = React.createElement(Lazy, props);