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

package/runtime/development.mjs

@@ -1,7 +1,7 @@
 import {createDevCompilerBroker} from './dev-compiler-broker.mjs';
 import {spawn} from 'node:child_process';
 import {mkdir,readdir,readFile,writeFile,rm,link,copyFile,realpath,lstat} from 'node:fs/promises';
-import {randomUUID} from 'node:crypto';
+import {randomUUID,randomBytes} from 'node:crypto';
 import path from 'node:path';
 import {fileURLToPath} from 'node:url';
 import {rename} from './fs.mjs';
@@ -20,7 +20,13 @@ import {createDevRuntimePool} from './dev-runtime-pool.mjs';
 import {tryDevCssUpdate} from '../build/dev-css-update.mjs';
 import {devBuildReason} from './dev-build-reasons.mjs';
 import {publishDependencyGraph,affectedDependencies,canSkipUnopenedRoutes} from './dev-dependency-graph.mjs';
+import {selectiveDevelopmentRoutes} from './dev-route-selection.mjs';
 import {prepareDevNotification} from './dev-notification.mjs';
+import {writeAtomicFile} from './atomic-file.mjs';
+import {lazyImportIdentifier,materializeDevImport} from './dev-lazy-imports.mjs';
+import {discardLazyBuild} from './dev-lazy-staging.mjs';
+import {pruneDevelopmentStyles} from './dev-style-retention.mjs';
+import {createDevelopmentSessionOwner,pruneDevelopmentSessions,createRetiredGenerationCleanup} from './dev-session-retention.mjs';
 
 const packageRoot=fileURLToPath(new URL('../',import.meta.url));
 export function developmentRoute(routes,raw,config={}) {
@@ -79,23 +85,33 @@ function serverOptions(args) {
   return {hostname,port,backend,hostAi,profile,safe};
 }
 export async function develop(projectRoot,args,binary) {
-  return withBuildLock(projectRoot,root=>runDevelopment(root,args,binary),{development:true});
+  let entered=false;
+  try{return await withBuildLock(projectRoot,root=>{entered=true;return runDevelopment(root,args,binary);},{development:true});}
+  finally{if(entered)try{const {pruneCompilationStorage}=await import('../build/compilation-storage.mjs');await pruneCompilationStorage(projectRoot);}catch{/* Optional compilation-cache maintenance cannot change shutdown correctness. */}}
 }
 async function runDevelopment(projectRoot,args,binary) {
   const root=await realpath(projectRoot),options=serverOptions(args),session=randomUUID();
+  // Private IPC state survives compiler recycling without exposing the key in
+  // the browser's session metadata or any development manifest/notification.
+  const devActionSecret=randomBytes(32).toString('base64');
   const stateFile=path.join(root,'.prnext-dev.json'),home=path.join(root,'.prnext-dev',session);
   const diagnosticsDirectory=process.env.PRNEXT_INSPECT_DIR||path.join(home,'diagnostics');
   // The session is ours; never clean a path obtained from application config.
   const container=path.join(root,'.prnext-dev'),info=await lstat(container).catch(error=>{if(error.code!=='ENOENT')throw error;});
   if(info&&(!info.isDirectory()||info.isSymbolicLink()))throw Error('Development directory must be a real directory');
+  await pruneDevelopmentSessions(root);
   await mkdir(home,{recursive:true});
+  const sessionOwner=createDevelopmentSessionOwner(home,{session});
+  if(options.safe)sessionOwner.disable();
   await mkdir(diagnosticsDirectory,{recursive:true,mode:0o700});
   let compiler,gateway,watcher,timer,tools,hostRelay,hostRelayTask,stopping=false,current,discovery,typeChecker,readyState={state:'building'},typeErrors=[],sequence=0;
   let dependencyIndexValid=false;
   const lifecycle=new AbortController();
   let queue=Promise.resolve(),stateQueue=Promise.resolve(),output='.prnext',changes=new Set(),active=new Map(),failed=new Set();
   const failedPaths=new Set();
-  const generations=[],styleGenerations=[],retiring=new Set(),pins=new Map(),routeCache=new Map(),filter=createDevChangeFilter(root);
+  const requestedImports=new Set();
+  const generations=[],styleGenerations=[],retiring=new Set(),pins=new Map(),routeCache=new Map(),filter=createDevChangeFilter(root,{directoryEventsAreRecursive:process.platform==='darwin',ignore:relative=>relative===output||relative.startsWith(output+'/')});
+  const retiredCleanup=createRetiredGenerationCleanup({root,home,gateway:{request:(...args)=>gateway.request(...args)},stop});
   const compilerBroker=await createDevCompilerBroker({compile:(pattern,sources)=>serialized(async()=>{
     if(stopping)throw Error('Development is stopping');
     if(!discovery)await discover();
@@ -106,10 +122,10 @@ async function runDevelopment(projectRoot,args,binary) {
     if(!current||patterns.some(p=>!current.patterns.has(p)))await rebuild([...active.keys()]);
     return current.directory;
   })});
-  const runtimePool=createDevRuntimePool({binary,root,home,environment:{PRNEXT_DEV_COMPILER:compilerBroker.descriptor,PRNEXT_INSPECT_DIR:diagnosticsDirectory,...(options.profile?{PRNEXT_PROFILE:options.profile}:{})},onChild:child=>captureOutput({stderr:child.stderr,once:child.once.bind(child)},'runtime',{forwardStdout:false})});
+  const runtimePool=createDevRuntimePool({binary,root,home,environment:{PRNEXT_DEV_COMPILER:compilerBroker.descriptor,PRNEXT_INSPECT_DIR:diagnosticsDirectory,...(options.profile?{PRNEXT_PROFILE:options.profile}:{})},onBeforeChild:()=>sessionOwner.beforeSpawn(),onReady:(child,info,ticket)=>sessionOwner.spawned(ticket,child,[info.pid]),onChild:child=>captureOutput({stderr:child.stderr,once:child.once.bind(child)},'runtime',{forwardStdout:false})});
   const toolSnapshot=()=>({...readyState,safeMode:options.safe,sequence:readyState.sequence??sequence,session,typeErrors,
     routes:(discovery?.project.routes||[]).filter(route=>!route.internal).map(route=>({path:(discovery.config.basePath||'')+(route.pattern==='/'?'/':route.pattern),kind:route.kind,source:route.file?path.relative(root,route.file).replaceAll(path.sep,'/'):undefined,compiled:current?.patterns.has(route.pattern)||false,pinned:[...pins.values()].some(pin=>pin.pattern===route.pattern)})),
-    cache:{activeRoutes:active.size,pinnedRoutes:new Set([...pins.values()].map(pin=>pin.pattern)).size,retainedGenerations:generations.length,lookupEntries:routeCache.size,compiler:readyState.compiler,transforms:readyState.transforms,persistentTransforms:true,dependencyIndex:dependencyIndexValid?{valid:true,...current?.manifest.devDependencyIndex}:{valid:false}}});
+    cache:{activeRoutes:active.size,pinnedRoutes:new Set([...pins.values()].map(pin=>pin.pattern)).size,retainedGenerations:generations.length,retiredCleanupPending:retiredCleanup.pending,lookupEntries:routeCache.size,compiler:readyState.compiler,transforms:readyState.transforms,persistentTransforms:true,dependencyIndex:dependencyIndexValid?{valid:true,...current?.manifest.devDependencyIndex}:{valid:false}}});
   function captureOutput(child,source,{forwardStdout=true}={}){
     for(const [stream,level] of [[child.stdout,'info'],[child.stderr,'error']]){
       stream?.setEncoding('utf8');
@@ -124,10 +140,23 @@ async function runDevelopment(projectRoot,args,binary) {
     const route=developmentRoute(discovery.project.routes,raw,discovery.config);
     if(routeCache.size>=256)routeCache.delete(routeCache.keys().next().value);routeCache.set(key,route);return route;
   }
+  let publicationFailures=0,lastPublicationFailure;
   const writeState=value=>{
-    const task=stateQueue.then(async()=>{if(value)readyState=value;const temporary=stateFile+'.'+randomUUID()+'.tmp';
-      const {notification,text}=prepareDevNotification({...readyState,safeMode:options.safe,typeErrors});
-      try{await writeFile(temporary,text);await rename(temporary,stateFile);if(gateway&&!gateway.stopping)await gateway.request('notify',{value:notification});}finally{await rm(temporary,{force:true});}});
+    const task=stateQueue.then(async()=>{
+      const next=value||readyState;
+      const {notification,text}=prepareDevNotification({...next,safeMode:options.safe,typeErrors,...(publicationFailures?{publication:{failures:publicationFailures,lastFailure:lastPublicationFailure}}:{})});
+      try{await writeAtomicFile(stateFile,text);}
+      catch(error){
+        publicationFailures++;lastPublicationFailure=error.atomicFile||{operation:'publish-development-state',code:error.code||'UNKNOWN'};
+        // A failed publication must leave the last complete state readable.
+        // This private bounded receipt contains no source path or payload.
+        await writeFile(path.join(diagnosticsDirectory,'state-publication.json'),JSON.stringify({failures:publicationFailures,lastFailure:lastPublicationFailure,lastSuccessfulSequence:readyState.sequence??null})+'\n',{mode:0o600}).catch(()=>{});
+        tools?.addServerLog('error','Development state publication failed.',{process:'compiler',...lastPublicationFailure});
+        throw error;
+      }
+      readyState=next;
+      if(gateway&&!gateway.stopping)await gateway.request('notify',{value:notification});
+    });
     stateQueue=task.catch(()=>{});return task;
   };
   const serialized=run=>{const task=queue.then(()=>{if(stopping)throw Error('Development is stopping');return run();});queue=task.catch(()=>{});return task;};
@@ -135,7 +164,9 @@ async function runDevelopment(projectRoot,args,binary) {
     if(!compiler||compiler.exitCode!==null||compiler.signalCode){
       const cache=await privateCacheDirectory(root,'dev-compiler-v8');
       await pruneCompilerCache(cache);
+      const ticket=sessionOwner.beforeSpawn();
       compiler=spawn(process.execPath,[path.join(packageRoot,'build/dev-worker.mjs')],{stdio:['pipe','pipe','pipe','ipc'],windowsHide:true,env:{...process.env,NODE_ENV:process.env.NODE_ENV||'development',...(options.safe?{PRNEXT_BUILD_CACHE:'0'}:{}),...(cache?{NODE_COMPILE_CACHE:cache}:{})}});
+      sessionOwner.spawned(ticket,compiler);
       captureOutput(compiler,'compiler');
     }
     const child=compiler;
@@ -153,14 +184,17 @@ async function runDevelopment(projectRoot,args,binary) {
     if(options.safe)discovery={...discovery,eager:true};
     const {writeTypedRoutes}=await import('../build/typed-routes.mjs');
     await writeTypedRoutes(root,discovery.project,discovery.config);
-    if(!typeChecker||typeChecker.inactive){const {startTypeChecker}=await import('../build/typescript-dev.mjs');typeChecker=await startTypeChecker(root,discovery.config,errors=>{typeErrors=errors;if(!stopping)void writeState().catch(console.error);});}
+    if(!typeChecker||typeChecker.inactive){const {startTypeChecker}=await import('../build/typescript-dev.mjs');typeChecker=await startTypeChecker(root,discovery.config,errors=>{typeErrors=errors;if(!stopping)void writeState().catch(console.error);},{onBeforeChild:()=>sessionOwner.beforeSpawn(),onChild:(child,ticket)=>sessionOwner.spawned(ticket,child)});}
   }
   async function launch(manifest,directory){
     const runtime=options.safe?undefined:await runtimePool.take(directory).catch(error=>{tools?.addServerLog('warn','Worker warmup was unavailable; starting a fresh worker.',{process:'runtime'});return undefined;});
+    if(!runtime)sessionOwner.disable();
     const env={...process.env,NODE_ENV:process.env.NODE_ENV||'development',PRNEXT_INSPECT_DIR:diagnosticsDirectory,PRNEXT_DEV_COMPILER:compilerBroker.descriptor};
     delete env.PRNEXT_DEV_BROKER;
     if(runtime)env.PRNEXT_DEV_BROKER=runtime.descriptor;
+    const ticket=sessionOwner.beforeSpawn();
     const child=spawn(binary,['start',root,'--build-dir',directory,'--worker',path.join(root,directory,'runtime/worker.mjs'),'--node',process.execPath,'--hostname','127.0.0.1','--port','0','--shutdown-on-stdin-eof',...options.backend],{stdio:['pipe','pipe','pipe'],windowsHide:true,env});
+    sessionOwner.spawned(ticket,child);
     captureOutput(child,'runtime',{forwardStdout:false});
     let output='';
     const port=await new Promise((resolve,reject)=>{
@@ -172,6 +206,8 @@ async function runDevelopment(projectRoot,args,binary) {
     return {id:manifest.buildId,child,runtime,port,directory};
   }
   async function rebuild(patterns,changedFiles=[],affectedRoutes,affectedModules,cause){
+    void retiredCleanup.retry();
+    if(retiredCleanup.pending>=64)throw Error('Development snapshots could not be removed. Close applications locking these files, then retry.');
     const startedAt=Date.now(),started=performance.now(),phases={};let mark=started;
     let reason=devBuildReason({initial:!current,safe:options.safe,changed:changedFiles,cause});
     await writeState({state:'building',reason});
@@ -180,21 +216,21 @@ async function runDevelopment(projectRoot,args,binary) {
       if(!options.safe)void runtimePool.warm().catch(()=>{});
       if(current&&!discovery.eager&&discovery.cssFast){
         const directory=path.relative(root,path.join(home,'styles-'+randomUUID())).replaceAll(path.sep,'/');
-        const styles=await tryDevCssUpdate({root,source:path.join(root,current.cssDirectory||current.directory),destination:path.join(root,directory),manifest:current.manifest,changed:changedFiles,sequence:sequence+1,cssEngine:discovery.config.cssEngine,snapshot,onFallback:code=>{reason=devBuildReason({changed:changedFiles,cause:code});}});
+        const styles=await tryDevCssUpdate({root,source:path.join(root,current.cssDirectory||current.directory),baseSource:path.join(root,current.directory),destination:path.join(root,directory),manifest:current.manifest,changed:changedFiles,sequence:sequence+1,cssEngine:discovery.config.cssEngine,onFallback:code=>{reason=devBuildReason({changed:changedFiles,cause:code});}});
         if(styles){
           await gateway.request('assets',{generation:styles.buildId,directory});
           try{styles.devDependencyIndex=await publishDependencyGraph(gateway,styles);dependencyIndexValid=true;}catch(error){dependencyIndexValid=false;await gateway.request('graph',{routes:[]});tools?.addServerLog('warn','Selective HMR unavailable: '+error.message,{process:'compiler'});}
-          sequence++;current.manifest=styles;current.cssDirectory=directory;current.cssOnly=true;current.affectedRoutes=undefined;current.changed=changed;
           styleGenerations.push({id:styles.buildId,directory});
+          await pruneDevelopmentStyles(styleGenerations,gateway,root);
+          sequence++;current.manifest=styles;current.cssDirectory=directory;current.cssOnly=true;current.affectedRoutes=undefined;current.changed=changed;
           reason=devBuildReason({cause:'css-only'});
           await writeState({state:'ready',reason,buildId:styles.buildId,clientManifest:styles.devClient,sequence,session,changed,cssOnly:true,listenerPid:gateway.child.pid,compiler:current.compiler,transforms:current.transforms});
           tools?.recordBuild({buildId:styles.buildId,reason:reason.summary,reasonCode:reason.code,sequence,time:Date.now(),startedAt,duration:performance.now()-started,phases:{styles:performance.now()-started},mode:'css',state:'ready'});
           console.log('Styles updated. '+reason.summary);
-          while(styleGenerations.length>3){const old=styleGenerations.shift();await gateway.request('retire',{generation:old.id});await gateway.request('forget',{generation:old.id});await rm(path.join(root,old.directory),{recursive:true,force:true,maxRetries:10,retryDelay:100});}
           await watcher?.refresh();return styles;
         }
       }
-      const result=await compilerRequest('build',{options:{...(discovery.eager?{}:{devRoutes:patterns}),devSafe:options.safe,devSequence:++sequence,devSession:session,devTools:tools?.bootstrap,devAffectedModules:affectedModules,devForceRefresh:options.safe||changedFiles.some(file=>/\.(?:css|scss|sass)$/.test(file)||/(?:postcss|browserslist|\.env|config)/.test(file))}});
+      const result=await compilerRequest('build',{options:{...(discovery.eager?{}:{devRoutes:patterns}),devSafe:options.safe,devSequence:++sequence,devSession:session,devActionSecret,devTools:tools?.bootstrap,devAffectedModules:affectedModules,devLazyActivated:[...requestedImports],devForceRefresh:options.safe||changedFiles.some(file=>/\.(?:css|scss|sass)$/.test(file)||/(?:postcss|browserslist|\.env|config)/.test(file))}});
       phases.compile=performance.now()-mark;mark=performance.now();
       if(stopping)throw Error('Development is stopping');
       const consumed=filter.acceptInputs(result.inputs||[]);
@@ -211,18 +247,30 @@ async function runDevelopment(projectRoot,args,binary) {
       catch(error){dependencyIndexValid=false;await gateway.request('graph',{routes:[]});affectedRoutes=undefined;affectedModules=undefined;tools?.addServerLog('warn','Selective HMR unavailable: '+error.message,{process:'compiler'});}
       const previous=current;current=next;current.compiler=result.compiler;current.transforms=result.transforms;generations.push(next);failed.clear();failedPaths.clear();
       current.manifest=manifest;current.changed=changed;current.patterns=new Set(discovery.eager?discovery.project.routes.map(route=>route.pattern):patterns);
-      const affected=Object.keys(manifest.app?.actions||{}).length?undefined:affectedRoutes;
-      current.affectedRoutes=affected;
-      await writeState({state:'ready',reason,buildId:manifest.buildId,clientManifest:manifest.devClient,sequence:manifest.devSequence,session,changed,affectedRoutes:affected,listenerPid:gateway.child.pid,compiler:result.compiler,transforms:result.transforms,routes:manifest.routes.filter(route=>!route.internal&&!route.devDeferred).map(route=>route.pattern)});
-      tools?.recordBuild({buildId:manifest.buildId,reason:reason.summary,reasonCode:reason.code,sequence:manifest.devSequence,time:Date.now(),startedAt,duration:performance.now()-started,phases,routes:patterns.length,state:'ready'});
-      console.log('Source compiled. '+reason.summary);
-      if(previous){
-        const retiringTask=(async()=>{await gateway.request('retire',{generation:previous.id}).catch(()=>{});await previous.runtime?.close();await stop(previous.child);})().finally(()=>retiring.delete(retiringTask));retiring.add(retiringTask);
+      for(const id of requestedImports)if(!manifest.devLazy?.modules.some(item=>item.id===id))requestedImports.delete(id);
+      let affected;
+      if(dependencyIndexValid&&affectedRoutes) {
+        const nextAffected=await affectedDependencies(gateway,changedFiles).catch(()=>undefined);
+        affected=selectiveDevelopmentRoutes(previous?.manifest,manifest,{changed:changedFiles,affectedRoutes,affectedModules,nextAffected});
       }
-      while(generations.length>3){const old=generations.shift();
-        // A deferred request may itself be awaiting this build. Never wait for
-        // its generation lease while holding the serialized compiler queue.
-        const cleanup=(async()=>{await gateway.request('retire',{generation:old.id});await old.runtime?.close();await stop(old.child);await gateway.request('forget',{generation:old.id});await rm(path.join(root,old.directory),{recursive:true,force:true,maxRetries:10,retryDelay:100});})().catch(error=>{if(!stopping)console.warn('Development generation cleanup: '+error.message);}).finally(()=>retiring.delete(cleanup));retiring.add(cleanup);
+      current.affectedRoutes=affected;
+      try{
+        await writeState({state:'ready',reason,buildId:manifest.buildId,clientManifest:manifest.devClient,sequence:manifest.devSequence,session,changed,affectedRoutes:affected,listenerPid:gateway.child.pid,compiler:result.compiler,transforms:result.transforms,routes:manifest.routes.filter(route=>!route.internal&&!route.devDeferred).map(route=>route.pattern)});
+        tools?.recordBuild({buildId:manifest.buildId,reason:reason.summary,reasonCode:reason.code,sequence:manifest.devSequence,time:Date.now(),startedAt,duration:performance.now()-started,phases,routes:patterns.length,state:'ready'});
+        console.log('Source compiled. '+reason.summary);
+      }finally{
+        // Activation already succeeded. A locked readiness receipt must not
+        // keep obsolete runtimes alive or bypass the generation bound. Retire
+        // through the gateway so existing requests drain before their owner
+        // closes; the newly activated current runtime remains available.
+        if(previous){
+          const retiringTask=(async()=>{await gateway.request('retire',{generation:previous.id}).catch(()=>{});await previous.runtime?.close();await stop(previous.child);})().finally(()=>retiring.delete(retiringTask));retiring.add(retiringTask);
+        }
+        while(generations.length>3){const old=generations.shift();
+          // A deferred request may itself be awaiting this build. Never wait for
+          // its generation lease while holding the serialized compiler queue.
+          const cleanup=retiredCleanup.enqueue(old).finally(()=>retiring.delete(cleanup));retiring.add(cleanup);
+        }
       }
       await watcher?.refresh();
       return manifest;
@@ -230,6 +278,18 @@ async function runDevelopment(projectRoot,args,binary) {
   }
   const updateInfo=()=>({buildId:current.manifest.buildId,clientManifest:current.manifest.devClient,pagesManifest:current.manifest.pagesManifest,sequence:current.manifest.devSequence,session,changed:current.changed,cssOnly:current.cssOnly,affectedRoutes:current.affectedRoutes});
   async function ensure(raw,client,exact=false){
+    if(new URL(raw,'http://local').pathname.startsWith('/_prnext/lazy/'))return serialized(async()=>{
+      const id=lazyImportIdentifier(raw);
+      if(!id||!current)throw Error('Unknown deferred import identifier');
+      let built,failure,lazy;
+      try{lazy=await materializeDevImport({root,current,id,compile:async request=>{
+        const result=await compilerRequest('build',{options:{devRoutes:[...current.patterns],devSafe:options.safe,devSequence:sequence,devSession:session,devActionSecret,devTools:tools?.bootstrap,devLazyRequest:request,devLazyBase:{cacheId:current.manifest.cacheId}}});
+        built=result.manifest;return built;
+      }});}catch(error){failure=error;throw error;}
+      finally{try{await discardLazyBuild(root,built);}catch(error){if(failure){failure.cleanupError=error;failure.message+='; deferred compiler staging cleanup also failed';}else throw error;}}
+      requestedImports.add(id);
+      return {lazy};
+    });
     const resolve=()=>exact?discovery.project.routes.find(route=>route.pattern===raw):findRoute(raw);
     const warm=discovery&&resolve();
     if(!stopping&&current&&warm&&active.has(warm.pattern)&&current.patterns.has(warm.pattern)){
@@ -288,7 +348,7 @@ async function runDevelopment(projectRoot,args,binary) {
       // Keep each native data-cache bridge alive until its externally owned
       // Node process has drained after() work and cache fills on stdin EOF.
       await runtimePool.close();
-      await Promise.all([tools?.close(),...generations.map(g=>stop(g.child)),...retiring]);
+      await Promise.all([tools?.close(),...generations.map(g=>stop(g.child)),...retiring,retiredCleanup.close()]);
       await queue.catch(()=>{});await compilerBroker.close();await stateQueue;await rm(home,{recursive:true,force:true,maxRetries:10,retryDelay:100});await rm(stateFile,{force:true});
     })();return closing;
   };
@@ -303,7 +363,7 @@ async function runDevelopment(projectRoot,args,binary) {
       return {...updateInfo(),...result};
     })});
     await writeState({state:'building',session});
-    gateway=new DevGateway(binary,root,{...options,onEnsure:ensure,onFatal:fatal,
+    gateway=new DevGateway(binary,root,{...options,onEnsure:ensure,onFatal:fatal,onBeforeChild:()=>sessionOwner.beforeSpawn(),onChild:(child,ticket)=>sessionOwner.spawned(ticket,child),
       onOpen:message=>{const route=discovery&&findRoute(message.path);if(route)pins.set(message.client,{pattern:route.pattern,connection:message.connection});},
       onClose:message=>{if(pins.get(message.client)?.connection===message.connection)pins.delete(message.client);}});
     const listener=await gateway.ready;

package/runtime/env.mjs

@@ -57,6 +57,15 @@ export function loadEnvConfig(projectRoot, { dev = false, env = process.env, mod
   return { combinedEnv: env, parsedEnv, loadedEnvFiles };
 }
 
+/** Native runtime settings need the same project env as its Node workers.
+ * Return a fresh object: persistent apps must never share loaded credentials.
+ */
+export function productionEnvironment(projectRoot, {env=process.env}={}) {
+  const combined={...env,NODE_ENV:env.NODE_ENV||'production'};
+  loadEnvConfig(projectRoot,{dev:false,env:combined});
+  return combined;
+}
+
 export function shouldWatchProjectFile(filename) {
   if (!filename) return false;
   const parts = String(filename).split(/[\\/]/);

package/runtime/flight-delta.mjs

@@ -1,21 +1,72 @@
 import { randomBytes, createHmac } from 'node:crypto';
-import { deflateRawSync } from 'node:zlib';
+import { deflateRaw } from 'node:zlib';
 import { TYPE, MAX_VALUE, collectStream, deltaStream } from '../compat/flight-delta.cjs';
 
-export function createFlightStore({maxBytes=32*1024*1024,maxEntries=64,ttl=30000,maxCaptures=8,maxEncoders=2,now=Date.now}={}) {
-  const entries=new Map();let size=0,captures=0,encoders=0;
+export function createFlightStore({maxBytes=32*1024*1024,maxEntries=64,ttl=30000,maxCaptures=8,maxEncoders=2,now=Date.now,setTimer=setTimeout,clearTimer=clearTimeout}={}) {
+  if(!Number.isFinite(ttl)||ttl<0||typeof now!=='function'||typeof setTimer!=='function'||typeof clearTimer!=='function')throw new TypeError('Invalid Flight store expiration policy');
+  const entries=new Map();let size=0,captures=0,encoders=0,timer,timerExpires;
   function reserve(kind){if(kind==='capture'?captures>=maxCaptures:encoders>=maxEncoders)return;kind==='capture'?captures++:encoders++;let released=false;return()=>{if(released)return;released=true;kind==='capture'?captures--:encoders--;};}
   function remove(token){const entry=entries.get(token);if(entry){size-=entry.bytes.length;entries.delete(token);}}
-  function prune(){for(const[token,entry]of entries)if(entry.expires<=now())remove(token);while(size>maxBytes||entries.size>maxEntries)remove(entries.keys().next().value);}
+  function schedule(at){
+    let expires=Infinity;
+    for(const entry of entries.values())expires=Math.min(expires,entry.expires);
+    if(timer!==undefined&&timerExpires===expires)return;
+    if(timer!==undefined)clearTimer(timer);
+    timer=timerExpires=undefined;
+    if(!entries.size)return;
+    timerExpires=expires;
+    // One timer for the bounded store, not one per response. A cancelled cache
+    // entry must not leave its former deadline armed. Clamp long TTLs to Node's
+    // timer range; an early wake simply checks the authoritative clock again.
+    const handle=setTimer(()=>{
+      if(timer!==handle)return;
+      timer=timerExpires=undefined;prune(true);
+    },Math.min(2147483647,Math.max(1,expires-at)));
+    timer=handle;timer?.unref?.();
+  }
+  function prune(changed=false){
+    const at=now();
+    for(const[token,entry]of entries)if(entry.expires<=at){remove(token);changed=true;}
+    while(size>maxBytes||entries.size>maxEntries){remove(entries.keys().next().value);changed=true;}
+    // Ordinary hits keep the same timer without another full entry scan.
+    if(changed)schedule(at);
+  }
   return {
     get(token,identity){prune();const entry=entries.get(token);if(entry?.identity!==identity)return;return entry?.bytes;},
-    set(token,identity,bytes){if(bytes.length>MAX_VALUE)return;remove(token);entries.set(token,{identity,bytes,expires:now()+ttl});size+=bytes.length;prune();},
+    set(token,identity,bytes){if(bytes.length>MAX_VALUE)return;remove(token);entries.set(token,{identity,bytes,expires:now()+ttl});size+=bytes.length;prune(true);},
     capture:()=>reserve('capture'),encoder:()=>reserve('encoder'),get inFlight(){return {captures,encoders};},
     get bytes(){return size;},get size(){return entries.size;},
   };
 }
 const store=createFlightStore();
-export function compressedDeltaPolicy(acceptEncoding='') {
+const compress=value=>new Promise((resolve,reject)=>deflateRaw(value,{level:1},(error,result)=>error?reject(error):resolve(result)));
+
+// At most two probes (four small zlib jobs) across all stores and requests.
+// Admission never queues: a saturated probe keeps ordinary Flight. An aborted
+// caller stops waiting, but its slot remains occupied until native work ends.
+export function createCompressionProbe({maxConcurrent=2,compress:run=compress}={}) {
+  if(!Number.isInteger(maxConcurrent)||maxConcurrent<1||maxConcurrent>8||typeof run!=='function')throw new TypeError('Invalid Flight compression probe policy');
+  let active=0;
+  const probe=(raw,encoded,signal)=>{
+    signal?.throwIfAborted();
+    if(raw.length>64*1024||encoded.length+32>=raw.length||active>=maxConcurrent)return false;
+    active++;
+    const work=Promise.allSettled([Promise.resolve().then(()=>run(encoded)),Promise.resolve().then(()=>run(raw))])
+      .then(results=>results.every(result=>result.status==='fulfilled')&&results[0].value.length+32<results[1].value.length*0.9)
+      .finally(()=>{active--;});
+    if(!signal)return work;
+    return new Promise((resolve,reject)=>{
+      const abort=()=>{signal.removeEventListener('abort',abort);reject(signal.reason);};
+      signal.addEventListener('abort',abort,{once:true});
+      if(signal.aborted)abort();
+      work.then(resolve,reject).finally(()=>signal.removeEventListener('abort',abort));
+    });
+  };
+  Object.defineProperty(probe,'inFlight',{get:()=>active});
+  return probe;
+}
+const compressionProbe=createCompressionProbe();
+export function compressedDeltaPolicy(acceptEncoding='',{signal}={}) {
   const compressed=acceptEncoding.split(',').some(value=>{
     const [name,...parameters]=value.trim().toLowerCase().split(';');
     return /^(gzip|deflate|br|zstd|\*)$/.test(name)&&!parameters.some(p=>/^\s*q\s*=\s*0(?:\.0*)?\s*$/.test(p));
@@ -24,8 +75,7 @@ export function compressedDeltaPolicy(acceptEncoding='') {
   // This conservative, bounded probe is not the response compressor. It avoids
   // choosing thousands of references to JSON that gzip already compresses well.
   // A large/expensive chunk keeps ordinary Flight instead of delaying a flush.
-  return (raw,encoded)=>raw.length<=64*1024&&encoded.length+32<raw.length&&
-    deflateRawSync(encoded,{level:1}).length+32<deflateRawSync(raw,{level:1}).length*0.9;
+  return (raw,encoded)=>compressionProbe(raw,encoded,signal);
 }
 export async function differentialFlight(response,options,cache=store) {
   const headers=new Headers(options.headers), outgoing=new Headers(response.headers);
@@ -40,7 +90,7 @@ export async function differentialFlight(response,options,cache=store) {
       controller.enqueue(raw instanceof Uint8Array?raw:raw instanceof ArrayBuffer?new Uint8Array(raw):new TextEncoder().encode(String(raw??'')));controller.close();
     }});
     const collected=collectStream(body,{capture:!!releaseCapture,onComplete:bytes=>cache.set(token,identity,bytes),onFinally:releaseCapture});
-    encoded=base?await deltaStream(collected,base,{assess:compressedDeltaPolicy(headers.get('accept-encoding')||'')}):{delta:false,body:collected};
+    encoded=base?await deltaStream(collected,base,{assess:compressedDeltaPolicy(headers.get('accept-encoding')||'',{signal:options.signal})}):{delta:false,body:collected};
     if(!encoded.delta)releaseEncoder?.();
     else encoded.body=collectStream(encoded.body,{capture:false,onFinally:releaseEncoder});
   }catch(error){releaseEncoder?.();releaseCapture?.();throw error;}

package/runtime/fs.mjs

@@ -1,15 +1,22 @@
 import { rename as move } from 'node:fs/promises';
 import { setTimeout as delay } from 'node:timers/promises';
+import path from 'node:path';
 
 // Windows scanners and recently closed file handles can briefly deny rename.
 // Keep the atomic swap: never delete the destination to work around a lock.
-export async function rename(source, destination) {
-  const deadline = Date.now() + 2000;
-  for (let attempt = 0; ; attempt++) {
-    try { return await move(source, destination); }
-    catch (error) {
-      if (process.platform !== 'win32' || !['EPERM', 'EACCES', 'EBUSY'].includes(error.code) || Date.now() >= deadline) throw error;
-      await delay(Math.min(10 * (attempt + 1), 100));
+export function createAtomicRenamer({moveFile=move,wait=delay,platform=process.platform,now=()=>performance.now(),retryMs=2000}={}) {
+  return async function rename(source,destination) {
+    const started=now(),deadline=started+retryMs;
+    for(let attempt=1;;attempt++){
+      try{return await moveFile(source,destination);}
+      catch(error){
+        if(platform!=='win32'||!['EPERM','EACCES','EBUSY'].includes(error.code)||now()>=deadline){
+          error.atomicRename={operation:'rename',code:error.code||'UNKNOWN',attempts:attempt,elapsedMs:Math.max(0,now()-started),destination:path.basename(destination)};
+          throw error;
+        }
+        await wait(Math.min(10*attempt,100,Math.max(0,deadline-now())));
+      }
     }
-  }
+  };
 }
+export const rename=createAtomicRenamer();

package/runtime/lazy-import-client.mjs

@@ -0,0 +1,38 @@
+// Only emitted by the opt-in development compiler. Successful imports retain
+// native ESM caching; failed compilation is retryable after a source correction.
+const pending=new Map(),styles=new Map();
+function stylesheet(url){
+  const existing=[...document.querySelectorAll('link[rel="stylesheet"]')].find(link=>link.href===new URL(url,location.href).href);
+  if(existing?.sheet)return Promise.resolve();
+  if(existing&&styles.has(url))return styles.get(url);
+  const promise=new Promise((resolve,reject)=>{
+    const link=existing||document.createElement('link');
+    const timer=setTimeout(()=>finish(Error('Deferred stylesheet timed out')),30000);
+    const finish=error=>{clearTimeout(timer);link.removeEventListener('load',loaded);link.removeEventListener('error',failed);if(error){styles.delete(url);if(!existing)link.remove();reject(error);}else resolve();};
+    const loaded=()=>finish(),failed=()=>finish(Error('Deferred stylesheet failed to load'));
+    link.addEventListener('load',loaded,{once:true});link.addEventListener('error',failed,{once:true});
+    if(!existing){link.rel='stylesheet';link.href=url;document.head.appendChild(link);}
+  });
+  styles.set(url,promise);
+  void promise.then(()=>styles.delete(url),()=>styles.delete(url));
+  return promise;
+}
+export function lazyImport(id,basePath=''){
+  const key=basePath+':'+id;
+  if(pending.has(key))return pending.get(key);
+  const task=(async()=>{
+    const path='/_prnext/lazy/'+id;
+    const response=await fetch(`${basePath}/_prnext/ensure?path=${encodeURIComponent(path)}`,{cache:'no-store',credentials:'same-origin',signal:AbortSignal.timeout(120000)});
+    if(!response.ok)throw Error(await response.text());
+    const value=await response.json(),target=value.lazy;
+    if(!target||typeof target.url!=='string'||!Array.isArray(target.css))throw Error('Invalid deferred import response');
+    for(const url of [target.url,...target.css]){
+      const parsed=new URL(url,location.href);
+      if(parsed.origin!==location.origin||!parsed.pathname.includes('/_prnext/assets/'))throw Error('Invalid deferred import asset URL');
+    }
+    await Promise.all(target.css.map(stylesheet));
+    const module=await import(target.url);
+    return target.native?module:module.__prnextLazyModule;
+  })().finally(()=>pending.delete(key));
+  pending.set(key,task);return task;
+}

package/runtime/native-ppr.mjs

@@ -0,0 +1,35 @@
+import {createHash} from 'node:crypto';
+import {readFile, stat} from 'node:fs/promises';
+import path from 'node:path';
+import {escapeHtml} from './http.mjs';
+
+export const NATIVE_PPR_ARTIFACT_BYTES = 2 * 1024 * 1024;
+export const NATIVE_PPR_PREFIX_BYTES = 128 * 1024;
+export const sha256 = bytes => createHash('sha256').update(bytes).digest('hex');
+
+export function partialShell(artifact, route) {
+  const bootstrap = '<script>self.__PRNEXT_FLIGHT_STREAM__=self.__PRNEXT_FLIGHT_STREAM__||[];</script>' +
+    (route.client ? `<script type="module" async src="${escapeHtml(route.client)}"></script>` : '');
+  const end = artifact.shell.lastIndexOf('</body>');
+  if (end < 0 || !/<\/body><\/html>$/i.test(artifact.shell)) throw new Error('Invalid partial prerender document');
+  return artifact.shell.slice(0, end) + bootstrap + artifact.shell.slice(end);
+}
+
+// This is a private transport field, never an HTTP header. Rust has already
+// checked cache generation and committed these exact build bytes. Pinning the
+// same artifact gives the request one snapshot even if invalidation races Node.
+export async function nativePprArtifact({renderMode, manifest, route, url, distDir}) {
+  if (!renderMode?.startsWith('native-ppr:')) return null;
+  if (!manifest.config?.nativePprShell || manifest.dev || !/^[a-f\d]{64}$/.test(renderMode.slice(11))) throw new Error('Invalid native PPR continuation');
+  const pathname = new URL(url).pathname;
+  const descriptor = manifest.config.nativePprArtifacts?.find(item => item.routeId === route.id && item.path === pathname && item.artifactHash === renderMode.slice(11));
+  if (!descriptor || new URL(url).search || descriptor.artifact !== route.ppr?.[pathname]) throw new Error('Native PPR artifact does not match the route');
+  const filename = path.resolve(distDir, descriptor.artifact);
+  if (!descriptor.artifact.startsWith('static/') || !filename.startsWith(path.resolve(distDir) + path.sep) || (await stat(filename)).size > NATIVE_PPR_ARTIFACT_BYTES) throw new Error('Invalid native PPR artifact path or size');
+  const bytes = await readFile(filename);
+  if (bytes.length > NATIVE_PPR_ARTIFACT_BYTES || sha256(bytes) !== descriptor.artifactHash) throw new Error('Native PPR artifact changed after publication');
+  const artifact = JSON.parse(bytes);
+  const prefix = Buffer.from(partialShell(artifact, route).replace(/<\/body><\/html>$/i, ''));
+  if (artifact.version !== 1 || !artifact.postponed || artifact.complete || artifact.generic || sha256(prefix) !== descriptor.prefixHash || sha256(artifact.flight) !== descriptor.identity) throw new Error('Invalid native PPR snapshot');
+  return {artifact, descriptor};
+}

package/runtime/og/NOTICE.txt

@@ -1,4 +1,4 @@
-Image renderer: @vercel/og 1.0.3 (https://github.com/vercel/og), with bundled Satori 0.33.5 (https://github.com/vercel/satori). PRNext replaces embedded fflate 0.7.3 with fflate 0.7.5, bundles it, adds Node CommonJS globals and includes adjacent WASM/font assets. Optional sharp backends require librsvg 2.63.2 or newer; otherwise rendering uses resvg. Upstream bundled licenses are retained. Rebuild: node scripts/prepare-og.mjs.
+Image renderer: @vercel/og 1.0.3 (https://github.com/vercel/og), with bundled Satori 0.33.5 (https://github.com/vercel/satori). PRNext replaces embedded fflate 0.7.3 with fflate 0.7.5, bundles and minifies it with function/class names preserved, adds Node CommonJS globals and includes adjacent WASM/font assets. Optional sharp backends require librsvg 2.63.2 or newer; otherwise rendering uses resvg. Upstream bundled licenses are retained. Rebuild: node scripts/prepare-og.mjs.
 Geist Regular 1.800: Copyright 2024 The Geist Project Authors (https://github.com/vercel/geist-font.git), SIL OFL 1.1; LICENSE.Geist is the upstream OFL.txt.
 HarfBuzzJS 0.10.0: https://github.com/harfbuzz/harfbuzzjs; see LICENSE.harfbuzzjs.
 resvg-js 2.4.1: https://github.com/yisibl/resvg-js/tree/v2.4.1, MPL-2.0 (LICENSE).