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

package/runtime/dev-lazy-imports.mjs

@@ -0,0 +1,121 @@
+import path from 'node:path';
+import {constants} from 'node:fs';
+import {readdir,readFile,writeFile,stat,lstat,open,mkdtemp,link,rm} from 'node:fs/promises';
+
+export const MAX_LAZY_ASSET_BYTES=128*1024*1024;
+export const MAX_LAZY_ASSET_FILES=16384;
+const token=/^\/_prnext\/lazy\/([a-f0-9]{24})$/;
+export function lazyImportIdentifier(raw){return token.exec(new URL(raw,'http://local').pathname)?.[1];}
+
+function receiptFiles(receipt,cacheId){
+  if(!receipt||receipt.version!==1||typeof cacheId!=='string'||!cacheId||cacheId.length>256||receipt.baseCacheId!==cacheId||!Array.isArray(receipt.files))throw Error('Invalid or obsolete deferred asset receipt');
+  if(receipt.files.length>MAX_LAZY_ASSET_FILES)throw Error('Deferred import exceeded the asset count budget');
+  const names=new Set(),files=[];let total=0;
+  for(const file of receipt.files){
+    const name=file?.name;
+    if(typeof name!=='string'||!name||name.length>255||!/^[A-Za-z0-9_.-]+$/.test(name)||name==='.'||name==='..'||name.endsWith('.')||/^(?:con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\.|$)/i.test(name)||names.has(name.toLowerCase()))throw Error('Invalid or duplicate deferred asset receipt name');
+    if(!Number.isSafeInteger(file.bytes)||file.bytes<0||file.bytes>MAX_LAZY_ASSET_BYTES||(total+=file.bytes)>MAX_LAZY_ASSET_BYTES)throw Error('Deferred asset receipt exceeded the 128 MiB generation budget');
+    names.add(name.toLowerCase());files.push({name,bytes:file.bytes});
+  }
+  return files;
+}
+
+function regularAsset(info,bytes){
+  if(!info.isFile()||info.isSymbolicLink())throw Error('Invalid deferred asset: expected a regular file without symbolic links');
+  if(info.size!==bytes)throw Error('Deferred asset does not match the receipt byte size');
+  return info;
+}
+
+async function readReceiptAsset(filename,bytes,checked){
+  const expected=checked||regularAsset(await lstat(filename),bytes);
+  const file=await open(filename,constants.O_RDONLY|(constants.O_NOFOLLOW||0));
+  try{
+    const info=regularAsset(await file.stat(),bytes);
+    if(info.dev!==expected.dev||info.ino!==expected.ino)throw Error('Deferred asset changed after receipt validation');
+    // Metadata can race a writer. Read only the declared size plus one byte,
+    // rather than letting readFile allocate for a later, unbounded file size.
+    const data=Buffer.allocUnsafe(bytes);let offset=0;
+    while(offset<bytes){
+      const {bytesRead}=await file.read(data,offset,bytes-offset,offset);
+      if(!bytesRead)throw Error('Deferred asset ended before the receipt byte size');
+      offset+=bytesRead;
+    }
+    if((await file.read(Buffer.allocUnsafe(1),0,1,bytes)).bytesRead)throw Error('Deferred asset exceeded the receipt byte size');
+    return data;
+  }finally{await file.close();}
+}
+
+async function readExistingReceiptAsset(filename,bytes){
+  const info=await lstat(filename);
+  if(!info.isFile()||info.isSymbolicLink())throw Error('Invalid deferred asset: expected a regular file without symbolic links');
+  if(info.size!==bytes)throw Error('Deferred compilation produced a conflicting immutable asset');
+  return readReceiptAsset(filename,bytes,info);
+}
+
+/** Only registered tokens can reach the compiler. The caller serializes builds. */
+export async function materializeDevImport({root,current,id,compile}){
+  const registry=current.manifest.devLazy;
+  if(!registry||!registry.modules.some(item=>item.id===id))throw Error('Unknown deferred import identifier');
+  if(registry.outputs[id])return registry.outputs[id];
+  const built=await compile({id,modules:registry.modules,bridges:registry.bridges,shared:registry.shared});
+  const next=built.devLazy,target=next?.outputs?.[id];
+  if(!target)throw Error('The compiler did not produce the requested deferred import');
+  // New server implementations cannot be added to a running immutable runtime.
+  // Existing Server Action proxies are reused through the static ESM bridges.
+  if(Object.keys(built.app?.actions||{}).some(key=>!Object.hasOwn(current.manifest.app?.actions||{},key)))throw Error('A deferred module introduced a new Server Action. Import that action statically or disable experimental.lazyDynamicImports.');
+  const source=path.join(built.outputDirectory,'assets'),destination=path.join(root,current.directory,'assets');
+  const received=Object.hasOwn(built,'devLazyAssets');
+  const files=received?receiptFiles(built.devLazyAssets,current.manifest.cacheId):await readdir(source,{withFileTypes:true}),pending=[];let bytes=0;
+  if(files.length>MAX_LAZY_ASSET_FILES)throw Error('Deferred import exceeded the asset count budget');
+  if(received){
+    for(const directory of [source,destination]){const info=await lstat(directory);if(!info.isDirectory()||info.isSymbolicLink())throw Error('Invalid deferred asset directory');}
+    // Validate every declared file before reading any payload or publishing.
+    for(const file of files)file.info=regularAsset(await lstat(path.join(source,file.name)),file.bytes);
+  }
+  for(const file of files){
+    if(!received&&(!file.isFile()||file.name!==path.basename(file.name)))throw Error('Invalid deferred asset');
+    if(!received&&(await stat(path.join(source,file.name))).size>MAX_LAZY_ASSET_BYTES)throw Error('Deferred import asset exceeded the 128 MiB generation budget');
+    const data=received?await readReceiptAsset(path.join(source,file.name),file.bytes,file.info):await readFile(path.join(source,file.name));
+    const previous=await(received?readExistingReceiptAsset(path.join(destination,file.name),file.bytes):readFile(path.join(destination,file.name))).catch(error=>{if(error.code!=='ENOENT')throw error;});
+    if(previous){if(!previous.equals(data))throw Error('Deferred compilation produced a conflicting immutable asset');continue;}
+    bytes+=data.length;
+    if(bytes+(current.lazyAssetBytes||0)>MAX_LAZY_ASSET_BYTES)throw Error('Deferred import assets exceeded the 128 MiB generation budget');
+    pending.push([file.name,data]);
+  }
+  if(pending.length){
+    // Partial writes stay outside the served assets directory. A hard link
+    // publishes a complete file atomically and exclusively without replacing an
+    // immutable asset, even if another writer wins between inspection and I/O.
+    const temporary=await mkdtemp(path.join(root,current.directory,'.lazy-publish-'));
+    current.lazyAssetBytes=(current.lazyAssetBytes||0)+bytes;
+    let retained=0,failure;
+    try{
+      for(const [name,data]of pending)await writeFile(path.join(temporary,name),data,{flag:'wx'});
+      for(const [name,data]of pending){
+        // A failed publication can have an uncertain outcome. Keep its charge
+        // conservatively; a retry can reuse a complete asset without recharging.
+        retained+=data.length;
+        try{await link(path.join(temporary,name),path.join(destination,name));}
+        catch(error){
+          if(error.code!=='EEXIST')throw error;
+          const existing=received?await readExistingReceiptAsset(path.join(destination,name),data.length):await readFile(path.join(destination,name));
+          if(!existing.equals(data))throw Error('Deferred compilation produced a conflicting immutable asset');
+          retained-=data.length;
+        }
+      }
+    }catch(error){failure=error;}
+    try{
+      await rm(temporary,{recursive:true,force:true,maxRetries:10,retryDelay:100});
+      // Reclaim only unpublished bytes after deletion of our private staging
+      // files is confirmed. Complete public files are never removed on failure.
+      current.lazyAssetBytes-=bytes-retained;
+    }catch(error){
+      if(failure){failure.cleanupError=error;failure.message+='; deferred asset staging cleanup also failed';}
+      else failure=error;
+    }
+    if(failure)throw failure;
+  }
+  registry.modules=next.modules;registry.bridges=next.bridges;registry.shared=next.shared;
+  Object.assign(registry.outputs,next.outputs);
+  return target;
+}

package/runtime/dev-lazy-staging.mjs

@@ -0,0 +1,14 @@
+import { lstat, realpath, rm } from 'node:fs/promises';
+import path from 'node:path';
+
+/** Delete only an unpublished direct-child stage created by our lazy compiler. */
+export async function discardLazyBuild(root, built) {
+  if (!built?.devLazyTemporary) return;
+  const canonicalRoot = await realpath(root), directory = path.resolve(built.outputDirectory);
+  if (path.dirname(directory) !== canonicalRoot ||
+      !/^\.prnext-build-[a-f0-9-]{36}$/.test(path.basename(directory))) throw Error('Invalid deferred staging directory');
+  const info = await lstat(directory).catch(error => { if (error.code !== 'ENOENT') throw error; });
+  if (!info) return;
+  if (!info.isDirectory() || info.isSymbolicLink() || await realpath(directory) !== directory) throw Error('Invalid deferred staging directory');
+  await rm(directory, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 });
+}

package/runtime/dev-style-retention.mjs

@@ -0,0 +1,15 @@
+import {rm} from 'node:fs/promises';
+import path from 'node:path';
+
+// Asset-only generations do not own backend/compiler requests. Drain their
+// asset leases and finish deleting the excess snapshot before announcing ready.
+export async function pruneDevelopmentStyles(generations,gateway,root){
+  while(generations.length>3){
+    const old=generations[0];
+    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});
+    // Keep failed deletions tracked so a later update can retry their cleanup.
+    generations.shift();
+  }
+}

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';
@@ -21,6 +21,10 @@ 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 {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';
 
 const packageRoot=fileURLToPath(new URL('../',import.meta.url));
 export function developmentRoute(routes,raw,config={}) {
@@ -83,6 +87,9 @@ export async function develop(projectRoot,args,binary) {
 }
 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.
@@ -95,7 +102,8 @@ async function runDevelopment(projectRoot,args,binary) {
   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 compilerBroker=await createDevCompilerBroker({compile:(pattern,sources)=>serialized(async()=>{
     if(stopping)throw Error('Development is stopping');
     if(!discovery)await discover();
@@ -124,10 +132,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;};
@@ -180,21 +201,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 +232,26 @@ 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);
+      for(const id of requestedImports)if(!manifest.devLazy?.modules.some(item=>item.id===id))requestedImports.delete(id);
       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);
-      }
-      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);
+      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=(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);
+        }
       }
       await watcher?.refresh();
       return manifest;
@@ -230,6 +259,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)){

package/runtime/flight-delta.mjs

@@ -2,14 +2,38 @@ import { randomBytes, createHmac } from 'node:crypto';
 import { deflateRawSync } 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;},
   };

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/vendor/nft/LICENSE

@@ -0,0 +1,7 @@
+Copyright 2019 Vercel, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/vendor/nft/README.md

@@ -0,0 +1,16 @@
+# Node File Trace
+
+The `out/` files and MIT license are unchanged files from `@vercel/nft` 1.11.0.
+`upstream.json` records the exact npm archive integrity and every file's SHA-256.
+`node scripts/vendor-nft.mjs verify` checks those bytes and the complete inventory.
+
+This copy uses PRNext's explicit dependencies, including glob 14.0.2 and
+minimatch 11.0.1. Upstream 1.11.0 still declares glob 13; overriding a workspace
+lockfile would not repair that dependency for independently installed consumers.
+The tracing implementation itself has no local patches. Its runtime, resolver,
+filesystem, native tracing and relocated standalone contracts are tested with
+the patched dependency versions.
+
+When upstream supports the patched dependencies, prefer returning to its normal
+package after validating the same contracts. Updates to this copy must retain
+the upstream license, reviewed archive integrity and complete byte inventory.

package/vendor/nft/out/analyze.d.ts

@@ -0,0 +1,8 @@
+import { Job } from './node-file-trace';
+export interface AnalyzeResult {
+    assets: Set<string>;
+    deps: Set<string>;
+    imports: Set<string>;
+    isESM: boolean;
+}
+export default function analyze(id: string, code: string, job: Job): Promise<AnalyzeResult>;