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

package/runtime/compile-cache.mjs

@@ -1,8 +1,35 @@
 import {flushCompileCache} from 'node:module';
+import {lstatSync,realpathSync,writeFileSync,unlinkSync} from 'node:fs';
+import {randomUUID} from 'node:crypto';
+import {hostname} from 'node:os';
+import path from 'node:path';
+import {pruneCompilerCache} from './compile-cache-retention.mjs';
 let pending;
+let managedDirectory;
+let lastMaintenance=0,maintenance;
+// Native workers opt in explicitly. Never maintain a caller-supplied global
+// NODE_COMPILE_CACHE, and reject links in both framework-owned path components.
+try{
+  const root=process.env.PRNEXT_MANAGED_COMPILE_CACHE_ROOT;
+  if(root&&process.env.NODE_COMPILE_CACHE&&process.env.NODE_DISABLE_COMPILE_CACHE!=='1'){
+    const canonical=realpathSync(root),base=path.join(canonical,'.prnext-cache'),directory=path.join(base,'node-compile-v1');
+    if(realpathSync(process.env.NODE_COMPILE_CACHE)===directory&&[base,directory,process.env.NODE_COMPILE_CACHE].every(folder=>{const info=lstatSync(folder);return info.isDirectory()&&!info.isSymbolicLink();})){
+      const lease=path.join(directory,`.lease-${process.pid}-${randomUUID()}.json`);
+      writeFileSync(lease,JSON.stringify({pid:process.pid,host:hostname()}),{flag:'wx',mode:0o600});
+      managedDirectory=directory;
+      process.once('exit',()=>{try{unlinkSync(lease);}catch{}});
+    }
+  }
+}catch{/* A lease failure leaves this process's cache unmanaged. */}
 // Flush after imports settle so later workers can reuse compiled code even
 // while this worker stays warm. Disk failure is an optimization miss only.
 export function scheduleCompileCacheFlush(){
   if(pending||!process.env.NODE_COMPILE_CACHE||process.env.NODE_DISABLE_COMPILE_CACHE==='1')return;
-  pending=setTimeout(()=>{pending=undefined;try{flushCompileCache();}catch{}},1000);pending.unref();
+  pending=setTimeout(()=>{
+    pending=undefined;try{flushCompileCache();}catch{}
+    if(managedDirectory&&!maintenance&&Date.now()-lastMaintenance>=60000){
+      lastMaintenance=Date.now();
+      maintenance=pruneCompilerCache(managedDirectory,{maxBytes:128*1024*1024,maxFiles:4096}).finally(()=>{maintenance=undefined;});
+    }
+  },1000);pending.unref();
 }

package/runtime/dev-client.mjs

@@ -4,6 +4,7 @@ import { createConsoleCapture, isDevicePreview } from './dev-console.mjs';
 import { createDevToolsClient } from './dev-tools-client.mjs';
 import { createDevErrorOverlay } from './dev-error-overlay.mjs';
 import { collectDevIssues, formatDevIssuesForAI } from './dev-error-report.mjs';
+import { canSkipDevelopmentUpdate } from './dev-route-selection.mjs';
 
 const state = globalThis.__PRNEXT_DEV__ ||= {
   applications: new Map(), modules: new Map(), buildId: null, manifest: null,
@@ -154,7 +155,7 @@ function typeDiagnostics(errors) {
 }
 async function applyUpdate(message, {navigation=false}={}) {
   if(message.session&&state.session&&message.session!==state.session){reload('Development server restarted. Page reloaded.');return;}
-  if(message.sequence&&message.sequence<=(state.sequence||0))return;
+  if(message.sequence&&message.sequence<=(state.sequence||0)&&!(navigation&&state.skippedUpdate?.buildId===message.buildId))return;
   if (state.applying) {
     if(!state.queued||(message.sequence||0)>=(state.queued.sequence||0))state.queued={...message,navigation};
     const pending=state.applied;await pending;
@@ -174,7 +175,8 @@ async function applyUpdate(message, {navigation=false}={}) {
   const refreshStarted=performance.now();
   const localPath=location.pathname.slice((state.basePath||'').length)||'/';
   const affected=message.affectedRoutes;
-  if(state.confirmed&&affected&&!affected.some(pattern=>pattern.includes('[')||pattern===localPath||pattern+'/'===localPath)){
+  if(canSkipDevelopmentUpdate({confirmed:state.confirmed,navigation,ensuring:state.ensuring,affectedRoutes:affected,routes:message.routes,pathname:localPath})){
+    state.skippedUpdate={buildId:message.buildId};
     state.buildId=message.buildId;state.sequence=message.sequence;state.lastRefresh={buildId:message.buildId,durationMs:0,changed,skipped:true};
     document.documentElement.dataset.prnextDevBuild=message.buildId;
     if(hasCriticalIssue()&&state.issueKind==='build'){clearError();if(state.typeErrors)typeDiagnostics(state.typeErrors);}
@@ -221,6 +223,7 @@ async function applyUpdate(message, {navigation=false}={}) {
     state.buildId = message.buildId;
     if(message.sequence)state.sequence=message.sequence;
     state.manifest = manifest;
+    state.skippedUpdate=undefined;
     document.documentElement.dataset.prnextDevBuild = message.buildId;
     state.lastRefresh={buildId:message.buildId,durationMs:Math.round(performance.now()-refreshStarted),changed};
     await painted();state.confirmed=true;
@@ -277,7 +280,7 @@ function connect(options) {
     const response=await fetch(`${options.basePath||''}/_prnext/ensure?client=${state.clientId}&path=${encodeURIComponent(url.pathname+url.search)}`,{cache:'no-store',credentials:'same-origin'});
     if(!response.ok)throw Error(await response.text());
     const update=await response.json();
-    if(update.buildId!==state.buildId)await applyUpdate(update,{navigation:true});
+    if(update.buildId!==state.buildId||state.skippedUpdate?.buildId===update.buildId)await applyUpdate(update,{navigation:true});
     }finally{state.ensuring--;}
   };
   const source = new EventSource(`${options.basePath || ''}/_prnext/dev?client=${state.clientId}&path=${encodeURIComponent(location.pathname+location.search)}`);

package/runtime/dev-gateway.mjs

@@ -1,9 +1,10 @@
 import {spawn} from 'node:child_process';
 
 export class DevGateway {
-  constructor(binary,root,{hostname,port,onEnsure,onOpen,onClose,onFatal}) {
+  constructor(binary,root,{hostname,port,onEnsure,onOpen,onClose,onFatal,onBeforeChild=()=>{},onChild=()=>{}}) {
     this.next=0;this.pending=new Map();this.stopping=false;
-    this.child=spawn(binary,['dev-gateway',root,'--hostname',hostname,'--port',String(port)],{stdio:['pipe','pipe','inherit'],windowsHide:true});
+    const ticket=onBeforeChild();
+    this.child=spawn(binary,['dev-gateway',root,'--hostname',hostname,'--port',String(port)],{stdio:['pipe','pipe','inherit'],windowsHide:true});onChild(this.child,ticket);
     this.closed=new Promise(resolve=>this.child.once('close',resolve));
     this.ready=new Promise((resolve,reject)=>{
       const timer=setTimeout(()=>{reject(Error('Development listener did not start'));this.child.kill();},15000);

package/runtime/dev-route-selection.mjs

@@ -0,0 +1,64 @@
+const globalInput = /(?:^|\/)(?:package(?:-lock)?\.json|pnpm-lock\.yaml|yarn\.lock|(?:tsconfig|jsconfig)\.json|(?:prnext|next|contentlayer|postcss|tailwind)\.config\.|\.env|(?:src\/)?(?:middleware|proxy)\.[^/]+$|pages\/_document\.|(?:global-error|global-not-found)\.)/;
+const generatedRouteFields = new Set(['module', 'client', 'css', 'cssScopes']);
+function stable(value) {
+  if (Array.isArray(value)) return value.map(stable);
+  if (value && typeof value === 'object') return Object.fromEntries(Object.keys(value).sort().map(key => [key, stable(value[key])]));
+  return value;
+}
+const signature = value => JSON.stringify(stable(value));
+const routeContract = manifest => manifest.routes.map(route => Object.fromEntries(Object.entries(route).filter(([key]) => !generatedRouteFields.has(key)))).sort((a, b) => a.id.localeCompare(b.id));
+function actionContract(manifest) {
+  const ids = Object.keys(manifest.app?.actions || {}).sort();
+  if (!ids.length) return [];
+  const metadata = manifest.devActions;
+  if (metadata?.version !== 1 || metadata.complete !== true || manifest.devDependencyStatus?.complete !== true || !Array.isArray(metadata.actions)) return;
+  const modules = new Set((manifest.devModules || []).map(record => record.route));
+  const routed = new Set((manifest.devDependencies || []).flatMap(record => record.files));
+  if (signature(metadata.actions.map(action => action.id).sort()) !== signature(ids)) return;
+  const owners = new Set();
+  for (const action of metadata.actions) {
+    const owner = action.file + '\0' + action.binding;
+    if (!modules.has(action.file) || !routed.has(action.file) || owners.has(owner) || !Array.isArray(action.runtimes)) return;
+    owners.add(owner);
+  }
+  return [...metadata.actions].sort((a, b) => (a.file + '\0' + a.binding).localeCompare(b.file + '\0' + b.binding));
+}
+
+// Both committed graphs participate: removed imports belong to the old graph,
+// newly introduced imports to the new one. No partial/unknown graph is proof.
+export function selectiveDevelopmentRoutes(previous, next, { changed, affectedRoutes, affectedModules = [], nextAffected } = {}) {
+  if (!previous || !changed?.length || !Array.isArray(affectedRoutes) || !nextAffected || nextAffected.complete !== true || !Array.isArray(nextAffected.unknown) || nextAffected.unknown.length || !Array.isArray(nextAffected.routes) ||
+      previous.devDependencyStatus?.complete === false || next.devDependencyStatus?.complete === false || changed.some(file => globalInput.test(file))) return;
+  // The visible URL is not proof of the rendered route under server rewrites,
+  // localized routing, or intercepted/parallel branches. Keep these global
+  // until the browser can certify every visible route identity.
+  for (const manifest of [previous, next]) if (manifest.middleware || manifest.config?.i18n ||
+      Object.values(manifest.customRoutes?.rewrites || {}).some(rules => rules.length) ||
+      manifest.routes.some(route => route.parallel || route.interception)) return;
+  if (signature([previous.config, previous.customRoutes, routeContract(previous)]) !== signature([next.config, next.customRoutes, routeContract(next)])) return;
+  const before = actionContract(previous), after = actionContract(next);
+  if (!before || !after || previous.app?.actionKey !== next.app?.actionKey ||
+      signature(before.map(({id, ...action}) => action)) !== signature(after.map(({id, ...action}) => action))) return;
+  const modules = new Set([...affectedModules, ...(nextAffected.modules || [])]);
+  for (let i = 0; i < before.length; i++) if (before[i].id !== after[i].id && !modules.has(before[i].file)) return;
+  const routes = [...new Set([...affectedRoutes, ...nextAffected.routes])].sort();
+  return Buffer.byteLength(JSON.stringify(routes)) <= 32 * 1024 ? routes : undefined;
+}
+
+// An ensure/navigation transaction must prepare the new loader even when its
+// destination differs from location.pathname until history is committed.
+export function canSkipDevelopmentUpdate({ confirmed, navigation, ensuring, affectedRoutes, routes, pathname }) {
+  if (!confirmed || navigation || ensuring || !Array.isArray(affectedRoutes) || !Array.isArray(routes)) return false;
+  let parts; try { parts = pathname.split('/').filter(Boolean).map(decodeURIComponent); } catch { return false; }
+  const matches = pattern => {
+    const segments = pattern.split('/').filter(Boolean); let index = 0;
+    for (const segment of segments) {
+      if (/^\[\[\.\.\.[^\]]+\]\]$/.test(segment)) return true;
+      if (/^\[\.\.\.[^\]]+\]$/.test(segment)) return index < parts.length;
+      if (index >= parts.length || !(segment.startsWith('[') && segment.endsWith(']')) && segment !== parts[index]) return false;
+      index++;
+    }
+    return index === parts.length;
+  };
+  return routes.some(matches) && !affectedRoutes.some(matches);
+}

package/runtime/dev-runtime-pool.mjs

@@ -5,11 +5,12 @@ import {fileURLToPath} from 'node:url';
 import path from 'node:path';
 import {EventEmitter} from 'node:events';
 
-export function createDevRuntimePool({binary,root,home,environment={},onChild=()=>{}}){
+export function createDevRuntimePool({binary,root,home,environment={},onBeforeChild=()=>{},onChild=()=>{},onReady=()=>{}}){
   let spare,disposed=false;const children=new Set();
   function create(){
     if(disposed)throw Error('Development runtime is closed');
     const token=randomBytes(32).toString('base64url');
+    const ticket=onBeforeChild();
     const child=spawn(binary,['dev-spare',root,'--node',process.execPath,'--script',fileURLToPath(new URL('./dev-runtime-spare.mjs',import.meta.url))],{cwd:root,windowsHide:true,stdio:['pipe','pipe','pipe'],env:{...process.env,...environment,NODE_ENV:'development',PRNEXT_DEV_SPARE_TOKEN:token}});
     children.add(child);onChild(child);
     const messages=new EventEmitter();let buffer='';child.stdout.setEncoding('utf8');child.stdout.on('data',chunk=>{buffer+=chunk;if(buffer.length>65536){child.kill();return;}for(let end;(end=buffer.indexOf('\n'))>=0;){const line=buffer.slice(0,end);buffer=buffer.slice(end+1);try{const message=JSON.parse(line);if(message.type)messages.emit(message.type,message);}catch{}}});
@@ -22,7 +23,7 @@ export function createDevRuntimePool({binary,root,home,environment={},onChild=()
       const message=value=>{clean();resolve(value);};
       messages.on(type,message);child.once('exit',exit);child.once('error',fail);
     });
-    const ready=wait('warm');ready.catch(()=>{if(spare?.child===child)spare=undefined;void stop(child);});
+    const ready=wait('warm').then(info=>{onReady(child,info,ticket);return info;});ready.catch(()=>{if(spare?.child===child)spare=undefined;void stop(child);});
     return {child,token,ready,wait};
   }
   async function stop(child){

package/runtime/dev-runtime-spare.mjs

@@ -48,7 +48,7 @@ const broker=net.createServer(socket=>{
   socket.on('close',()=>{const owned=controls.delete(socket);if(owned&&!controls.size&&ready)process.stdin.emit('end');});
 });
 broker.maxConnections=16;
-broker.listen(0,'127.0.0.1',()=>{broker.unref();announce({type:'warm',port:broker.address().port});});
+broker.listen(0,'127.0.0.1',()=>{broker.unref();announce({type:'warm',port:broker.address().port,pid:process.pid});});
 let control='';const arm=chunk=>{control+=chunk;if(control.length>8192)process.exit(1);if(!control.includes('\n'))return;process.stdin.off('data',arm);
   let message;try{message=JSON.parse(control.trim());}catch{process.exit(1);}if(message?.type!=='arm'||armed)process.exit(1);
   void realpath(message.dist).then(dist=>{if(!dist.startsWith(root+path.sep))throw Error('Generation outside project');armed={dist};announce({type:'armed'});}).catch(()=>process.exit(1));

package/runtime/dev-session-retention.mjs

@@ -0,0 +1,154 @@
+import {randomUUID} from 'node:crypto';
+import {hostname} from 'node:os';
+import {constants, writeFileSync, renameSync, rmSync} from 'node:fs';
+import {lstat, open, opendir, rm} from 'node:fs/promises';
+import path from 'node:path';
+import {captureStorageDirectory,verifyStorageDirectories,sameStoragePath} from './storage-path.mjs';
+
+const marker = '.owner.json', disabledMarker = '.recovery-disabled', uuid = /^[a-f\d]{8}(?:-[a-f\d]{4}){3}-[a-f\d]{12}$/;
+const grace = 60_000, maxChildren = 4096, maxMarker = 64 * 1024;
+const alive = pid => {try {process.kill(pid, 0); return true;} catch (error) {return error.code !== 'ESRCH';}};
+const pid = value => Number.isSafeInteger(value) && value > 0;
+
+/** A ticket is durable before a spawn. An interrupted spawn/metadata update
+ * leaves the session ineligible for automatic recovery, never falsely idle. */
+export function createDevelopmentSessionOwner(home, {session, processId = process.pid, host = hostname(), now = Date.now, warn = console.warn} = {}) {
+  if (!uuid.test(session) || path.basename(home) !== session || !pid(processId)) throw Error('Invalid development session owner');
+  const state = {version: 1, session, token: randomUUID(), pid: processId, host, createdAt: now(), updatedAt: now(), eligible: true, children: [], pending: []};
+  function publish(initial = false) {
+    state.updatedAt = now();
+    const text = JSON.stringify(state) + '\n';
+    if (Buffer.byteLength(text) > maxMarker) throw Error('Development owner metadata exceeds its budget');
+    const file = path.join(home, marker);
+    if (initial) {writeFileSync(file, text, {flag: 'wx', mode: 0o600}); return;}
+    const temporary = file + '.' + randomUUID() + '.tmp';
+    try {writeFileSync(temporary, text, {flag: 'wx', mode: 0o600}); renameSync(temporary, file);}
+    finally {rmSync(temporary, {force: true});}
+  }
+  publish(true);
+  function disable() {
+    // A separate create-only marker also works if Windows has temporarily
+    // locked the owner receipt. A spawn may proceed only once this safeguard
+    // or its pending ticket is durable.
+    try {writeFileSync(path.join(home, disabledMarker), 'Incomplete development child ownership.\n', {flag: 'wx', mode: 0o600});}
+    catch (error) {if (error.code !== 'EEXIST') throw error;}
+    state.eligible = false; try {publish();} catch { /* The create-only marker forbids cleanup. */ }
+  }
+  return {
+    beforeSpawn() {
+      if (!state.eligible) return null;
+      if (state.pending.length >= 128 || state.children.length >= maxChildren) {disable(); return null;}
+      const ticket = randomUUID(); state.pending.push(ticket); try {publish();} catch {disable();} return ticket;
+    },
+    spawned(ticket, child, descendants = []) {
+      if (!state.eligible) return;
+      if (!state.pending.includes(ticket)) {disable(); return;}
+      if (!pid(child?.pid) || descendants.some(value => !pid(value))) {state.eligible = false; try {disable();} catch { /* The pre-spawn ticket remains durable. */ } return;}
+      for (const value of [child.pid, ...descendants]) if (!state.children.includes(value)) state.children.push(value);
+      state.pending = state.pending.filter(value => value !== ticket);
+      try {publish();} catch (error) {state.eligible = false; try {disable();} catch { /* The pre-spawn ticket remains durable. */ } warn('Development session recovery disabled: ' + (error.code || 'metadata publication failed'));}
+    },
+    disable,
+  };
+}
+
+async function readOwner(home) {
+  const name = path.join(home, marker), info = await lstat(name);
+  if (!info.isFile() || info.isSymbolicLink() || info.size > maxMarker) return;
+  const file = await open(name, constants.O_RDONLY | (constants.O_NOFOLLOW || 0));
+  try {
+    const bytes = Buffer.alloc(maxMarker + 1), {bytesRead} = await file.read(bytes, 0, bytes.length, 0);
+    if (bytesRead > maxMarker) return;
+    const text = bytes.toString('utf8', 0, bytesRead), value = JSON.parse(text);
+    if (value.version !== 1 || value.session !== path.basename(home) || !uuid.test(value.session) || !uuid.test(value.token) || !pid(value.pid) || typeof value.host !== 'string' || value.host.length > 255 || !Number.isSafeInteger(value.createdAt) || !Number.isSafeInteger(value.updatedAt) || value.updatedAt < value.createdAt || value.eligible !== true || !Array.isArray(value.pending) || value.pending.length || !Array.isArray(value.children) || value.children.length > maxChildren || value.children.some(value => !pid(value))) return;
+    return {value, text};
+  } finally {await file.close();}
+}
+
+async function ordinaryTree(home, budget, snapshots) {
+  const directory = await captureStorageDirectory(home);
+  if (!directory) return false;
+  snapshots.push(directory);
+  for await (const entry of await opendir(home)) {
+    if (++budget.files > 32_768) return false;
+    const file = path.join(home, entry.name), info = await lstat(file);
+    if (info.isSymbolicLink()) return false;
+    if (info.isDirectory()) {if (!await ordinaryTree(file, budget, snapshots)) return false;}
+    else if (!info.isFile() || (budget.bytes += info.size) > 2 * 1024 ** 3) return false;
+  }
+  return true;
+}
+
+/** Called while the project's exclusive development lock is held. Legacy,
+ * foreign, active, ambiguous and unmarked sessions are always preserved. */
+export async function pruneDevelopmentSessions(root, {host = hostname(), now = Date.now(), isAlive = alive, graceMs = grace, remove = rm} = {}) {
+  const report = {removed: 0, retained: 0, failed: 0};
+  // The caller already holds the canonical project's development lock. Do not
+  // recanonicalize a replaced root into a different project's storage.
+  root = path.resolve(root);
+  const container = path.join(root, '.prnext-dev');
+  let info;
+  try {info = await lstat(container);} catch (error) {if (error.code === 'ENOENT') return report; throw error;}
+  if (!info.isDirectory() || info.isSymbolicLink()) return report;
+  const ancestors = [await captureStorageDirectory(root), await captureStorageDirectory(container)];
+  if (!await verifyStorageDirectories(ancestors)) return report;
+  let scanned = 0;
+  for await (const entry of await opendir(container)) {
+    if (++scanned > 256) break;
+    if (!entry.isDirectory() || !uuid.test(entry.name)) {report.retained++; continue;}
+    const home = path.join(container, entry.name);
+    try {
+      const snapshots = [...ancestors, await captureStorageDirectory(home)];
+      if (!await verifyStorageDirectories(snapshots)) {report.retained++; continue;}
+      const owner = await readOwner(home);
+      if (await lstat(path.join(home, disabledMarker)).then(() => true, error => {if (error.code === 'ENOENT') return false; throw error;})) {report.retained++; continue;}
+      const inactive = value => value.host === host && value.updatedAt <= now - graceMs && value.createdAt <= now && ![value.pid, ...value.children].some(isAlive);
+      if (!owner || !inactive(owner.value) || !await verifyStorageDirectories(snapshots) || !await ordinaryTree(home, {files: 0, bytes: 0}, snapshots) || !await verifyStorageDirectories(snapshots)) {report.retained++; continue;}
+      // Validate the same marker and lifetime after the bounded tree walk. A
+      // currently running session can never be deleted merely because it is old.
+      const current = await readOwner(home), directory = await lstat(home);
+      const disabled = await lstat(path.join(home, disabledMarker)).then(() => true, error => {if (error.code === 'ENOENT') return false; throw error;});
+      if (disabled || !current || current.text !== owner.text || !inactive(current.value) || !directory.isDirectory() || directory.isSymbolicLink() || !await verifyStorageDirectories(snapshots)) {report.retained++; continue;}
+      await remove(home, {recursive: true, force: true, maxRetries: 3, retryDelay: 100}); report.removed++;
+    } catch {report.failed++;}
+  }
+  return report;
+}
+
+/** Failed generation cleanup remains in this retryable queue, including the
+ * exact completed phase. Nothing is deleted before requests have drained. */
+export function createRetiredGenerationCleanup({root, home, gateway, stop, remove = rm, warn = console.warn}) {
+  const pending = new Map(); let running;
+  const ownedHome = path.resolve(home);
+  const ancestry = directory => [path.resolve(root), path.join(path.resolve(root), '.prnext-dev'), ownedHome, directory];
+  async function storage(item, directory) {
+    item.snapshots ??= await Promise.all(ancestry(directory).map(captureStorageDirectory));
+    return verifyStorageDirectories(item.snapshots);
+  }
+  async function clean(item) {
+    const directory = path.resolve(root, item.generation.directory);
+    if (!sameStoragePath(path.dirname(directory), ownedHome) || !uuid.test(path.basename(directory)) || item.generation.id !== path.basename(directory)) throw Error('Invalid retired development generation');
+    if (!await storage(item, directory)) throw Error('Development generation storage changed');
+    if (item.phase === 0) {await gateway.request('retire', {generation: item.generation.id}); item.phase++;}
+    if (!await storage(item, directory)) throw Error('Development generation storage changed');
+    if (item.phase === 1) {await item.generation.runtime?.close(); item.phase++;}
+    if (item.phase === 2) {await stop(item.generation.child); item.phase++;}
+    if (item.phase === 3) {await gateway.request('forget', {generation: item.generation.id}); item.phase++;}
+    const snapshots = [...item.snapshots];
+    if (!await storage(item, directory) || !await ordinaryTree(directory, {files: 0, bytes: 0}, snapshots) || !await verifyStorageDirectories(snapshots)) throw Error('Development generation storage changed');
+    await remove(directory, {recursive: true, force: true, maxRetries: 10, retryDelay: 100});
+  }
+  const retry = () => {
+    if (running) return running;
+    running = (async () => {
+      for (const [id, item] of [...pending]) {
+        try {await clean(item); pending.delete(id);}
+        catch (error) {warn('Development generation cleanup: ' + error.message);}
+      }
+    })().finally(() => {running = undefined;});
+    return running;
+  };
+  return {get pending() {return pending.size;}, enqueue(generation) {if (!pending.has(generation.id)) pending.set(generation.id, {generation, phase: 0}); return retry();}, retry,
+    async close() {await running; for (const item of pending.values()) {const directory=path.resolve(root,item.generation.directory);if(await storage(item,directory))await item.generation.runtime?.close();else await stop(item.generation.runtime?.child);await stop(item.generation.child);}},
+  };
+}

package/runtime/development.mjs

@@ -20,11 +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={}) {
@@ -83,7 +85,9 @@ 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();
@@ -95,7 +99,10 @@ async function runDevelopment(projectRoot,args,binary) {
   // 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;
@@ -104,6 +111,7 @@ async function runDevelopment(projectRoot,args,binary) {
   const failedPaths=new Set();
   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();
@@ -114,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');
@@ -156,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;
@@ -174,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)=>{
@@ -193,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});
@@ -233,7 +248,11 @@ async function runDevelopment(projectRoot,args,binary) {
       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;
+      let affected;
+      if(dependencyIndexValid&&affectedRoutes) {
+        const nextAffected=await affectedDependencies(gateway,changedFiles).catch(()=>undefined);
+        affected=selectiveDevelopmentRoutes(previous?.manifest,manifest,{changed:changedFiles,affectedRoutes,affectedModules,nextAffected});
+      }
       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)});
@@ -250,7 +269,7 @@ async function runDevelopment(projectRoot,args,binary) {
         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);
+          const cleanup=retiredCleanup.enqueue(old).finally(()=>retiring.delete(cleanup));retiring.add(cleanup);
         }
       }
       await watcher?.refresh();
@@ -329,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;
   };
@@ -344,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,5 +1,5 @@
 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,setTimer=setTimeout,clearTimer=clearTimeout}={}) {
@@ -39,7 +39,34 @@ export function createFlightStore({maxBytes=32*1024*1024,maxEntries=64,ttl=30000
   };
 }
 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));
@@ -48,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);
@@ -64,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/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).