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

package/runtime/app-render.mjs

@@ -1,7 +1,8 @@
 import {reportRequestError,acknowledgeRequestError} from './instrumentation.mjs';
 import {currentTraceparent} from './trace.mjs';
 import React from 'react';
-import { randomUUID, createHmac, randomBytes } from 'node:crypto';
+import { randomUUID, createHmac } from 'node:crypto';
+import { developmentNavigationSecret } from '../compat/navigation-authorization.cjs';
 import diagnostics from '../compat/diagnostics.cjs';
 import { rscResourceLimits } from './profile.mjs';
 import { fontPreloads } from './font-preload.mjs';
@@ -28,6 +29,7 @@ import { installFetchCache } from './fetch-cache.mjs';
 import { partialArtifact, partialShell } from './app-partial.mjs';
 import { partialKeyMap } from './app-partial-model.mjs';
 import { partialIdentity } from './partial-artifact-cache.mjs';
+import {nativePprArtifact} from './native-ppr.mjs';
 import { isDraftRequest } from '../compat/draft.cjs';
 import { createRscLifecycle } from './rsc-lifecycle.mjs';
 import { trackRequestWork } from './request-work.mjs';
@@ -43,7 +45,6 @@ const metadata = new WeakMap();
 const artifacts = new WeakMap();
 const edgeManifests = new WeakMap();
 const emptyManifest = Object.freeze({});
-const developmentAuthorizationSecret = randomBytes(32).toString('hex');
 let nextId = 0;
 const pending = new Map();
 const noop = () => {};
@@ -506,7 +507,7 @@ export async function renderAppPage(options) {
   return differentialFlight(response, options);
 }
 
-async function renderAppPageInner({ modulePath, route = {}, manifest = {}, distDir = path.dirname(path.dirname(modulePath)), url = 'http://localhost/', originalUrl, params = {}, method = 'GET', headers = {}, routingRequestHeaders, routingResolver, body = '', production = process.env.NODE_ENV === 'production', stream = false, signal, deferFinalizer }) {
+async function renderAppPageInner({ modulePath, route = {}, manifest = {}, distDir = path.dirname(path.dirname(modulePath)), url = 'http://localhost/', originalUrl, params = {}, method = 'GET', headers = {}, routingRequestHeaders, routingResolver, body = '', production = process.env.NODE_ENV === 'production', stream = false, signal, deferFinalizer, renderMode }) {
   if (route.htmlOnly) return { status:409, headers:{'content-type':'text/plain; charset=utf-8','cache-control':'private, no-store','x-prnext-document-navigation':'1'}, body:Buffer.from('This HTML-only page requires its prerendered document.') };
   let clientModules = manifest.app?.clientModules || emptyManifest;
   if (route.cacheConfig?.runtime === 'edge') {
@@ -522,7 +523,7 @@ async function renderAppPageInner({ modulePath, route = {}, manifest = {}, distD
   }
   const responseHeaders = { 'cache-control': 'private, no-cache, no-store, max-age=0', vary: 'RSC' };
   const request = { modulePath, routePattern: route.pattern, cacheConfig: route.cacheConfig, css: route.css || [], cssScopes: route.cssScopes || [], fonts: route.fonts || [], nonce: scriptNonce(headers), basePath: manifest.config?.basePath || '', trailingSlash: manifest?.config?.trailingSlash || false, skipTrailingSlashRedirect: manifest?.config?.skipTrailingSlashRedirect || false, url, originalUrl, params, method, headers, clientModules, production,
-    distDir, traceparent:currentTraceparent(), instrumentation:manifest.instrumentation, strictMode: manifest.config?.reactStrictMode !== false, cacheComponents: manifest.config?.cacheComponents, navigationCache: manifest.config?.navigationCache, authorizationSecret: production ? manifest.app?.actionKey : developmentAuthorizationSecret, partialPrefetching: manifest.config?.partialPrefetching, cacheLife: manifest.config?.cacheLife, cacheHandlers: manifest.config?.cacheHandlers, cacheHandler: manifest.config?.cacheHandler, cacheMaxMemorySize: manifest.config?.cacheMaxMemorySize, serverActions: manifest.config?.serverActions, previewModeId: manifest.previewModeId, actions: manifest.app?.actions || emptyManifest, actionKey: manifest.app?.actionKey };
+    distDir, traceparent:currentTraceparent(), instrumentation:manifest.instrumentation, strictMode: manifest.config?.reactStrictMode !== false, cacheComponents: manifest.config?.cacheComponents, navigationCache: manifest.config?.navigationCache, authorizationSecret: production ? manifest.app?.actionKey : developmentNavigationSecret(manifest.app?.actionKey), partialPrefetching: manifest.config?.partialPrefetching, cacheLife: manifest.config?.cacheLife, cacheHandlers: manifest.config?.cacheHandlers, cacheHandler: manifest.config?.cacheHandler, cacheMaxMemorySize: manifest.config?.cacheMaxMemorySize, serverActions: manifest.config?.serverActions, previewModeId: manifest.previewModeId, actions: manifest.app?.actions || emptyManifest, actionKey: manifest.app?.actionKey };
   if (route.parallel) {
     request.routingResolver = routingResolver;
     request.skipProxyUrlNormalize = manifest.config?.skipProxyUrlNormalize;
@@ -554,6 +555,8 @@ async function renderAppPageInner({ modulePath, route = {}, manifest = {}, distD
     }
   }
   const header = name => Object.entries(headers).find(([key]) => key.toLowerCase() === name)?.[1];
+  const native = await nativePprArtifact({renderMode, manifest, route, url, distDir});
+  if (native) request.nativePpr = native.descriptor;
   if (request.partialPrefetching && manifest.app?.actionKey) {
     // Preview identity includes authorization, but exposes no cookie material or
     // guessable credential hash. A changed login cannot reveal an old preview.
@@ -591,7 +594,7 @@ async function renderAppPageInner({ modulePath, route = {}, manifest = {}, distD
     const generic = route.pprGeneric?.find(item => Object.entries(item.params).every(([name, value]) => JSON.stringify(params[name]) === JSON.stringify(value)));
     const filename = (!originalUrl ? route.ppr?.[pathname] : undefined) || generic?.file;
     if (filename || route.pprFallback) {
-      const artifact = await partialArtifact({ request, route, manifest, filename, identity: filename === generic?.file ? filename : `${pathname}:${originalUrl ? new URL(originalUrl).pathname : ''}`, signal,
+      const artifact = native?.artifact || await partialArtifact({ request, route, manifest, filename, identity: filename === generic?.file ? filename : `${pathname}:${originalUrl ? new URL(originalUrl).pathname : ''}`, signal,
         regenerate: async build => (await import('./app-static.mjs')).prerenderAppRoute({ modulePath, route, manifest, distDir, production, renderMode:'isr',
           path: build?.generic?.path || pathname, originalUrl: build?.generic ? undefined : originalUrl,
           params: build?.generic?.params || params, partialParams: build?.generic?.unknown }),
@@ -672,6 +675,7 @@ async function renderPartialAppPage({ request, route, artifact, responseHeaders,
   const keys = [...partialKeyMap(artifact.keyScopes, request.params, removeBasePath(new URL(request.url).pathname, request.basePath))];
   const partialRequest = { ...request, partialFlight: artifact.flight, ...(keys.length ? { partialKeys: keys } : {}) };
   const headers = { ...artifact.headers, ...responseHeaders, 'x-prnext-prerender': artifact.complete ? 'complete' : 'partial', 'content-type': rsc ? 'text/x-component; charset=utf-8' : 'text/html; charset=utf-8' };
+  if (request.nativePpr) headers['x-prnext-native-ppr'] = request.nativePpr.artifactHash;
   const identity = partialIdentity(artifact);
   headers['x-prnext-ppr-id'] = identity;
   if (prefetch) {
@@ -703,7 +707,7 @@ async function renderPartialAppPage({ request, route, artifact, responseHeaders,
   let rendered;
   const cancel = async reason => { abort.abort(reason || new Error('Partial response cancelled')); await rendered?.cancel?.(reason); };
   const body = (async function* () {
-    let sent = 0;
+    let sent = request.nativePpr ? Buffer.byteLength(shell.replace(/<\/body><\/html>$/i, '')) : 0;
     const bounded = chunk => {
       sent += chunk.byteLength;
       if (sent > MAX_RESPONSE_BYTES) throw new Error('Response exceeds the 16 MiB PRNext limit');
@@ -712,7 +716,7 @@ async function renderPartialAppPage({ request, route, artifact, responseHeaders,
     try {
       // The committed bytes come straight from prerender. Even a blocked
       // request component cannot hold back this shared document shell.
-      yield bounded(Buffer.from(shell.replace(/<\/body><\/html>$/i, '')));
+      if (!request.nativePpr) yield bounded(Buffer.from(shell.replace(/<\/body><\/html>$/i, '')));
       const result = await continueFlight(combinedSignal, true);
       rendered = await renderProgressiveAppHtml({ result, request, route, responseHeaders, decodeFlight, signal: combinedSignal,
         partial: { shell, postponed: artifact.postponed, shellSent: true, resumeKeys: keys.map(([from, to]) => [to, from]) } });

package/runtime/app-stream-channel.mjs

@@ -1,5 +1,6 @@
 // One initial transferable chunk, then one chunk per reader pull. The initial
 // credit removes a round trip while keeping the queue bounded to 64 KiB.
+import { ownFlightStream } from '../compat/flight-delta.cjs';
 export const APP_STREAM_CHUNK_BYTES = 64 * 1024;
 
 export function workerStreamChannel(port, id) {
@@ -62,7 +63,7 @@ export function parentStreamChannel(port, id, cancelled) {
   let controller;
   let settlePull;
   let closed = false;
-  const body = new ReadableStream({
+  const body = ownFlightStream(new ReadableStream({
     start(value) { controller = value; },
     pull() {
       return new Promise(resolve => {
@@ -76,7 +77,7 @@ export function parentStreamChannel(port, id, cancelled) {
       port.postMessage({ id, type: 'cancel' });
       cancelled(reason);
     },
-  }, { highWaterMark: 0 });
+  }, { highWaterMark: 0 }));
   return {
     body,
     chunk(buffer, offset = 0, length = buffer?.byteLength) {

package/runtime/app-styles.mjs

@@ -32,7 +32,23 @@ export function appStyleManager(document, { timeout = 15_000 } = {}) {
       if (!records.length) sheets.delete(href);
     }
   }
-  function acquire(href, before, replace = false) {
+  // Initial HTML can contain many sheets. Index it once per synchronous
+  // prepare/commit operation, lazily when an untracked URL needs adoption.
+  // Never retain this snapshot across operations: external links may change.
+  function initialSheets() {
+    let index;
+    return (href, tracked) => {
+      if (!index) {
+        index = new Map();
+        for (const link of document.querySelectorAll('link[rel="stylesheet"]')) {
+          const url = link.href, links = index.get(url) || [];
+          links.push(link); index.set(url, links);
+        }
+      }
+      return index.get(href)?.find(link => !tracked.has(link));
+    };
+  }
+  function acquire(href, before, replace = false, initial = initialSheets()) {
     const records = sheets.get(href) || [];
     const current = records.at(-1);
     if (current && !replace) return current;
@@ -40,7 +56,7 @@ export function appStyleManager(document, { timeout = 15_000 } = {}) {
     // in place until commit. Discard older abandoned candidates immediately.
     if (replace) for (const record of [...records]) if (!record.active && !record.recovery && !reserved(record)) remove(href, record);
     const tracked = new Set(records.map(record => record.link));
-    const existing = replace ? undefined : [...document.querySelectorAll('link[rel="stylesheet"]')].find(link => link.href === href && !tracked.has(link));
+    const existing = replace ? undefined : initial(href, tracked);
     const link = existing || document.createElement('link');
     const sheet = { link, active: !!existing, ready: !!existing?.sheet, recovery: false };
     const retained = sheets.get(href) || [];
@@ -77,6 +93,7 @@ export function appStyleManager(document, { timeout = 15_000 } = {}) {
     async prepare(values = [], signal) {
       if (signal?.aborted) throw aborted();
       const wanted = urls(values);
+      const initial = initialSheets();
       const prepared = [];
       let before;
       // Establish cascade order before downloading. Re-inserting an already
@@ -85,7 +102,7 @@ export function appStyleManager(document, { timeout = 15_000 } = {}) {
       // when an existing sheet would otherwise need to move across that suffix.
       for (let index = wanted.length - 1; index >= 0; index--) {
         const href = wanted[index];
-        let sheet = acquire(href, before);
+        let sheet = acquire(href, before, false, initial);
         if (before && !(sheet.link.compareDocumentPosition(before) & 4)) sheet = acquire(href, before, true);
         prepared.push(sheet.promise);
         before = sheet.link;
@@ -113,12 +130,13 @@ export function appStyleManager(document, { timeout = 15_000 } = {}) {
     commit(values = []) {
       cleanup++;
       const wanted = new Set(urls(values));
+      const initial = initialSheets();
       const handedUrls = [...handed.keys()];
       const pinned = wanted.size === handed.size && [...wanted].every((href, index) => handedUrls[index] === href) ? handed : null;
       for (const href of wanted) {
         const records = sheets.get(href) || [];
         const prior = !pinned && handed.size ? records.find(record => record.active) || records.find(record => record.recovery) : undefined;
-        const sheet = pinned?.get(href) || prior || records.findLast(record => record.ready) || acquire(href);
+        const sheet = pinned?.get(href) || prior || records.findLast(record => record.ready) || acquire(href, undefined, false, initial);
         // Initial HTML links are render-blocking. A missing sheet is restored
         // on explicit recovery; normal navigation always prepares first.
         sheet.active = true; sheet.recovery = false; sheet.link.media = '';

package/runtime/atomic-file.mjs

@@ -0,0 +1,27 @@
+import {open,rm} from 'node:fs/promises';
+import {randomUUID} from 'node:crypto';
+import path from 'node:path';
+import {rename} from './fs.mjs';
+
+// The old destination stays readable until the complete replacement exists.
+// Keeping an injectable I/O boundary lets tests exercise real partial-write and
+// rename failures without depending on an antivirus or a physical disk fault.
+export function createAtomicFileWriter({openFile=open,moveFile=rename,removeFile=rm}={}){
+  return async function writeAtomicFile(filename,data){
+    const temporary=filename+'.'+randomUUID()+'.tmp';let file,created=false,failure,phase='create';
+    try{
+      file=await openFile(temporary,'wx',0o600);created=true;phase='write';await file.writeFile(data);phase='close';await file.close();file=undefined;
+      phase='publish';await moveFile(temporary,filename);
+    }catch(error){
+      error.atomicFile={operation:'publish-development-state',phase,code:error.code||'UNKNOWN',destination:path.basename(filename),...(error.atomicRename||{})};
+      failure=error;
+      throw error;
+    }finally{
+      await file?.close().catch(()=>{});
+      // This unpredictable temporary is owned by this invocation. Never remove
+      // the destination to work around a Windows lock.
+      if(created)try{await removeFile(temporary,{force:true});}catch(error){if(failure)failure.atomicFile.cleanupCode=error.code||'UNKNOWN';else throw error;}
+    }
+  };
+}
+export const writeAtomicFile=createAtomicFileWriter();

package/runtime/cache-components-rsc.mjs

@@ -57,7 +57,9 @@ globalThis[codecSymbol] = {
       chunks.push(Buffer.from(value));
     }
     if (failure) throw failure;
-    return Buffer.concat(chunks, size);
+    // Each chunk above is already an owned copy. A single chunk needs no
+    // second allocation; never expose the producer's mutable stream storage.
+    return chunks.length===1?chunks[0]:Buffer.concat(chunks, size);
   },
   async decode(bytes, encoded, context) {
     return createFromReadableStream(new ReadableStream({ start(controller) { controller.enqueue(bytes); controller.close(); } }), {

package/runtime/compile-cache-retention.mjs

@@ -0,0 +1,53 @@
+import {lstat,opendir,unlink,realpath} from 'node:fs/promises';
+import path from 'node:path';
+import {captureStorageDirectory,verifyStorageDirectories,sameStoragePath} from './storage-path.mjs';
+import {withBuildLock} from './project-lock.mjs';
+
+/** Bounded maintenance of a known, disposable compiler namespace. Open V8
+ * cache readers remain valid; an evicted future lookup is a cache miss. */
+export async function pruneCompilerCache(directory,{maxBytes=64*1024*1024,maxFiles=2048}={}){
+  if(!directory)return;
+  try{
+    const snapshot=await captureStorageDirectory(directory);if(!snapshot)return;
+    return await withBuildLock(directory,async canonical=>{
+      if(!sameStoragePath(canonical,directory)||!await verifyStorageDirectories([snapshot]))return;
+      return prune(canonical,{maxBytes,maxFiles});
+    });
+  }
+  catch{/* A busy or unverifiable maintenance owner wins; never wait on it. */}
+}
+async function prune(directory,{maxBytes,maxFiles}){
+  try{
+    const files=[];let scanned=0,complete=true;
+    const input=await lstat(directory);if(!input.isDirectory()||input.isSymbolicLink())return;
+    directory=await realpath(directory);
+    const initial=await captureStorageDirectory(directory);if(!initial)return;
+    async function collect(folder,depth,parents){
+      if(depth>3){complete=false;return;}
+      const snapshot=await captureStorageDirectory(folder),guards=[...parents,snapshot];
+      if(!snapshot||!await verifyStorageDirectories(guards)){complete=false;return;}
+      const entries=await opendir(folder);
+      for await(const entry of entries){
+        if(++scanned>8192){complete=false;break;}
+        if(entry.name.startsWith('.'))continue;
+        const name=path.join(folder,entry.name),info=await lstat(name).catch(()=>null);
+        if(!info||info.isSymbolicLink())continue;
+        if(info.isDirectory())await collect(name,depth+1,guards);
+        else if(info.isFile())files.push({name,size:info.size,time:info.mtimeMs,ino:info.ino,dev:info.dev,guards});
+        if(!complete)break;
+      }
+      if(!await verifyStorageDirectories(guards))complete=false;
+    }
+    const info=await lstat(directory);if(!info.isDirectory()||info.isSymbolicLink())return;
+    await collect(directory,0,[initial]);if(!complete)return;
+    files.sort((a,b)=>b.time-a.time);let bytes=0,retained=0;
+    for(let i=0;i<files.length;i++){
+      const file=files[i];
+      if(retained>=maxFiles||bytes+file.size>maxBytes){
+        if(!await verifyStorageDirectories(file.guards))return;
+        const current=await lstat(file.name).catch(()=>null);
+        if(current?.isFile()&&!current.isSymbolicLink()&&current.ino===file.ino&&current.dev===file.dev&&current.mtimeMs===file.time&&current.size===file.size&&sameStoragePath(await realpath(file.name),file.name)&&await verifyStorageDirectories(file.guards))await unlink(file.name).catch(()=>{});
+      }else{bytes+=file.size;retained++;}
+    }
+  }catch{/* Compiler cache retention cannot fail a request or build. */}
+}

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);}
@@ -195,12 +197,17 @@ async function applyUpdate(message, {navigation=false}={}) {
     const route = kind === 'pages' ? manifest.pages.find(route => route.pattern === application.router.snapshot().pathname) : null;
     const entry = kind === 'pages' ? route?.client : manifest.app?.client;
     if (!entry) { reload('The current route changed. Page reloaded.'); return; }
-    if(!message.cssOnly)await import(/* webpackIgnore: true */ entry);
+    if(!message.cssOnly){
+      await import(/* webpackIgnore: true */ entry);
+      // Activated deferred modules must register their updated component
+      // families before Refresh runs, even when their loader is already cached.
+      await Promise.all((manifest.lazy||[]).map(module=>import(/* webpackIgnore: true */ module.url)));
+    }
     const pending = state.pending;
     if (pending) await application.devPrepare?.(pending.options);
     if (state.unsafe) { reload('An edited module exports values outside React components. Page reloaded.'); return; }
     if (kind === 'app' && application.devPrepareStyles) await application.devPrepareStyles(manifest.app.routes);
-    else await updateStyles(kind === 'pages' ? route.css : application.devStyles?.(manifest.app.routes) || manifest.app.css);
+    else await updateStyles([...(kind === 'pages' ? route.css : application.devStyles?.(manifest.app.routes) || manifest.app.css),...(manifest.lazy||[]).flatMap(module=>module.css)]);
     if (kind === 'app') application.devStylesApplied?.(manifest.app.routes, { commit: !!message.cssOnly || !pending });
     // An unrelated type-only edit may publish a new generation without changing
     // any browser module. Keep its existing runtime/hydration issues and current
@@ -216,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;
@@ -272,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-file-changes.mjs

@@ -1,7 +1,7 @@
 import path from 'node:path';
 import {createHash} from 'node:crypto';
 import {createReadStream} from 'node:fs';
-import {stat, readdir} from 'node:fs/promises';
+import {stat, lstat, readdir, opendir} from 'node:fs/promises';
 import {shouldWatchProjectFile} from './env.mjs';
 
 function directoryFingerprint(entries) {
@@ -12,16 +12,27 @@ function directoryFingerprint(entries) {
 
 // Remember the bytes actually consumed by webpack, not the file's contents at
 // the end of a build: an edit made after a read must still trigger a rebuild.
-export function createDevInputSnapshot(roots, {maxEntries=512,maxBytes=1024*1024}={}) {
+export function createDevInputSnapshot(roots, {maxEntries=process.platform==='darwin'?8192:512,maxBytes=1024*1024}={}) {
   const inputs=new Map();
+  const limitedPrefixes=new Set();let globalLimited=false;
   let bytes=0;
+  function limited(relative) {
+    // Source files may overflow in many sibling folders. One source-root
+    // prefix remains bounded without invalidating a captured disjoint generator.
+    relative=relative==='.contentlayer/generated'||relative.startsWith('.contentlayer/generated/')?'.contentlayer/generated':relative.split('/')[0];
+    if(globalLimited)return;
+    if([...limitedPrefixes].some(prefix=>relative===prefix||relative.startsWith(prefix+'/')))return;
+    for(const prefix of limitedPrefixes)if(prefix.startsWith(relative+'/'))limitedPrefixes.delete(prefix);
+    limitedPrefixes.add(relative);
+    if(limitedPrefixes.size>32||[...limitedPrefixes].reduce((sum,value)=>sum+value.length*2,0)>4096){globalLimited=true;limitedPrefixes.clear();}
+  }
   function remember(relative,value) {
     if (inputs.has(relative)) {
       if (inputs.get(relative)!==value) inputs.set(relative,null);
       return;
     }
     const size=relative.length*2+value.length*2+64;
-    if (inputs.size>=maxEntries || bytes+size>maxBytes) return;
+    if (inputs.size>=maxEntries || bytes+size>maxBytes) {limited(value.startsWith('directory:')?relative:path.posix.dirname(relative)==='.'?relative:path.posix.dirname(relative));return;}
     inputs.set(relative,value);bytes+=size;
   }
   return {
@@ -38,14 +49,15 @@ export function createDevInputSnapshot(roots, {maxEntries=512,maxBytes=1024*1024
     async captureDirectory(relative) {
       // Called after an awaited content generator and before graph resolution.
       // Include its types/aggregate indexes, which may not be runtime imports.
-      if (!shouldWatchProjectFile(relative) || inputs.size>=maxEntries || bytes>=maxBytes) return;
+      if (!shouldWatchProjectFile(relative))return;
+      if(inputs.size>=maxEntries || bytes>=maxBytes){limited(relative);return;}
       const file=path.join(roots[0],relative);
       let entries;
       try {entries=await readdir(file,{withFileTypes:true});}
       catch(error){if(error.code==='ENOENT')return;throw error;}
       remember(relative,directoryFingerprint(entries));
       for(const entry of entries) {
-        if(inputs.size>=maxEntries || bytes>=maxBytes)break;
+        if(inputs.size>=maxEntries || bytes>=maxBytes){limited(relative);break;}
         const child=relative+'/'+entry.name;
         if(!shouldWatchProjectFile(child))continue;
         if(entry.isDirectory())await this.captureDirectory(child);
@@ -58,14 +70,90 @@ export function createDevInputSnapshot(roots, {maxEntries=512,maxBytes=1024*1024
         }
       }
     },
-    entries:()=>[...inputs],
+    entries:()=>{
+      const values=[...inputs],coverage={version:1,limitedPrefixes:[...limitedPrefixes],globalLimited};
+      if(values.length)values[0]=[...values[0],coverage];
+      else values.push([null,null,coverage]);
+      return values;
+    },
   };
 }
 
 // Generators may rewrite identical JSON/modules on every compilation. Retain
 // only bounded path/digest pairs, never file contents or full directory lists.
-export function createDevChangeFilter(root, {maxEntries=512,maxBytes=1024*1024}={}) {
+export function createDevChangeFilter(root, {directoryEventsAreRecursive=false,maxEntries=directoryEventsAreRecursive?8192:512,maxBytes=1024*1024,ignore=()=>false,maxTreeEntries=8192,maxTreeBytes=1024*1024,onUncertainDirectory=()=>{}}={}) {
   const fingerprints=new Map();
+  // Before the first build there are no consumed inputs to lose. A later
+  // acceptInputs without coverage metadata deliberately replaces this proof.
+  const trees=new Map(),diagnostics=new Map();let treeBytes=0,coverage={version:1,limitedPrefixes:[],globalLimited:false},consumedInputs=new Map();
+  const contains=(parent,file)=>file===parent||file.startsWith(parent+'/');
+  const allowed=file=>shouldWatchProjectFile(file)&&!ignore(file);
+  const limitedFor=file=>!coverage||coverage.globalLimited||coverage.limitedPrefixes.some(prefix=>contains(file,prefix)||contains(prefix,file));
+  function discardTree(file){const previous=trees.get(file);if(previous){trees.delete(file);treeBytes-=previous.bytes;}}
+  function uncertain(file,reason){
+    discardTree(file);
+    if(diagnostics.get(file)!==reason){
+      diagnostics.delete(file);diagnostics.set(file,reason);while(diagnostics.size>32)diagnostics.delete(diagnostics.keys().next().value);
+      onUncertainDirectory({directory:file.slice(0,256),reason});
+    }
+    return Object.assign(Error(`Cannot verify a coalesced directory change in ${file.slice(0,256)} (${reason}). The previous build is kept. Run a full build or narrow generated inputs before retrying.`),{code:'PRNEXT_RECURSIVE_CHANGE_UNVERIFIED'});
+  }
+  async function treeSnapshot(relative){
+    const observed=new Map();let entriesRead=0,retainedBytes=relative.length*2+128;
+    const incomplete=reason=>{throw Object.assign(Error('Incomplete recursive source snapshot'),{snapshotReason:reason});};
+    async function visit(name){
+      const file=path.join(root,name),before=await lstat(file);let value,semantic;
+      if(before.isSymbolicLink())incomplete('symbolic-link');
+      if(before.isDirectory()){
+        const entries=[],directory=await opendir(file);
+        for await(const entry of directory){if(++entriesRead>maxTreeEntries)incomplete('entry-capacity');entries.push(entry);}
+        value=directoryFingerprint(entries);
+        const watched=entries.filter(entry=>allowed(name+'/'+entry.name));semantic=directoryFingerprint(watched);
+        rememberObserved(name,value,semantic);
+        for(const entry of watched)await visit(name+'/'+entry.name);
+      }else if(before.isFile()){
+        const hash=createHash('sha256');for await(const chunk of createReadStream(file,{highWaterMark:64*1024}))hash.update(chunk);
+        value='file:'+hash.digest('hex');rememberObserved(name,value,value);
+      }else incomplete('special-file');
+      const after=await lstat(file);
+      if(before.dev!==after.dev||before.ino!==after.ino||before.size!==after.size||before.mtimeMs!==after.mtimeMs||before.ctimeMs!==after.ctimeMs)incomplete('changed-during-read');
+    }
+    function rememberObserved(file,value,semantic){
+      retainedBytes+=2*(file.length+value.length+semantic.length)+96;
+      if(observed.size>=maxTreeEntries||retainedBytes>maxTreeBytes)incomplete('memory-capacity');
+      observed.set(file,{value,semantic});
+    }
+    try{
+      await visit(relative);const hash=createHash('sha256');
+      for(const [file,value]of [...observed].sort(([a],[b])=>a.localeCompare(b)))hash.update(JSON.stringify([file,value.semantic]));
+      return {complete:true,observed,digest:hash.digest('hex'),bytes:retainedBytes};
+    }catch(error){return {complete:false,reason:error.snapshotReason||'read-failure'};}
+  }
+  function retainTree(file,snapshot){
+    discardTree(file);
+    while(trees.size&&(trees.size>=32||treeBytes+snapshot.bytes>maxTreeBytes))discardTree(trees.keys().next().value);
+    trees.set(file,snapshot);treeBytes+=snapshot.bytes;
+  }
+  function observeTree(file,snapshot){
+    for(const [name,previous]of [...fingerprints])if(contains(file,name)&&allowed(name)&&!snapshot.observed.has(name)&&previous.value!=='missing')remember(name,'missing');
+    for(const [name,value]of consumedInputs)if(contains(file,name)&&allowed(name)&&snapshot.observed.get(name)?.value!==value)consumedInputs.delete(name);
+    for(const [directory,previous]of trees){
+      if(!contains(file,directory)&&!contains(directory,file))continue;
+      const same=[...previous.observed].every(([name,value])=>!contains(file,name)||snapshot.observed.get(name)?.semantic===value.semantic)
+        &&[...snapshot.observed].every(([name,value])=>!contains(directory,name)||previous.observed.get(name)?.semantic===value.semantic);
+      if(!same)discardTree(directory);
+    }
+  }
+  function observePath(file,value){
+    for(const [directory,snapshot]of trees){
+      if(contains(directory,file)){
+        const observed=snapshot.observed.get(file);
+        if(value===undefined||(value==='missing'?observed!==undefined:observed?.value!==value))discardTree(directory);
+      }else if(contains(file,directory))discardTree(directory);
+    }
+    for(const [name,previous]of consumedInputs)if(contains(file,name)&&(name!==file||previous!==value))consumedInputs.delete(name);
+    if(!value?.startsWith('directory:'))for(const [name]of [...fingerprints])if(name!==file&&contains(file,name))remember(name,value===undefined?undefined:'missing');
+  }
   let bytes=0;
   function remember(file,value) {
     const previous=fingerprints.get(file);
@@ -99,12 +187,39 @@ export function createDevChangeFilter(root, {maxEntries=512,maxBytes=1024*1024}=
   const filter=async files => {
     const changed=[];
     for (const file of files) {
+      if(directoryEventsAreRecursive&&allowed(file)){
+        let directory=false;try{directory=(await stat(path.join(root,file))).isDirectory();}catch{}
+        if(directory){
+          const snapshot=await treeSnapshot(file);
+          if(!snapshot.complete)throw uncertain(file,snapshot.reason);
+          if(limitedFor(file))throw uncertain(file,'input-coverage');
+          observeTree(file,snapshot);
+          const previous=trees.get(file);
+          const consumed=[...snapshot.observed].every(([name,value])=>consumedInputs.get(name)===value.value)
+            &&[...consumedInputs].every(([name,value])=>!contains(file,name)||!allowed(name)||!value.startsWith('file:')||snapshot.observed.has(name));
+          if((!previous||previous.digest!==snapshot.digest)&&!consumed)changed.push(file);
+          retainTree(file,snapshot);
+          diagnostics.delete(file);
+          continue;
+        }
+      }
       const value=await fingerprint(file), previous=fingerprints.get(file);
+      if(directoryEventsAreRecursive)observePath(file,value);
       if (value===undefined || !previous || previous.value!==value) changed.push(file);
       remember(file,value);
     }
     return changed;
   };
-  filter.acceptInputs=inputs=>{const changed=[];for(const [file,value] of inputs){if(fingerprints.get(file)?.value!==value)changed.push(file);remember(file,value);}return changed;};
+  filter.acceptInputs=inputs=>{
+    coverage=inputs.find(entry=>entry[2]?.version===1)?.[2];
+    // Only the latest bounded compiler receipt can acknowledge an uncached
+    // subtree. Event deduplication may keep older values in its independent LRU.
+    consumedInputs=new Map();for(const [file,value]of inputs)if(typeof file==='string'&&typeof value==='string')consumedInputs.set(file,value);
+    for(const [directory,snapshot]of trees){
+      if(limitedFor(directory)||inputs.some(([file,value])=>typeof file==='string'&&contains(directory,file)&&allowed(file)&&(value===null||snapshot.observed.get(file)?.value!==value)))discardTree(directory);
+    }
+    const changed=[];for(const [file,value] of inputs){if(typeof file!=='string')continue;if(fingerprints.get(file)?.value!==value)changed.push(file);remember(file,value);}return changed;
+  };
+  filter.recursiveDiagnostics=()=>[...diagnostics].map(([directory,reason])=>({directory,reason}));
   return filter;
 }

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);