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

package/build/index.mjs

@@ -6,12 +6,15 @@ import { writeRuntimeContract } from './runtime-contract.mjs';
 import { writeBuildOutput } from './output-contract.mjs';
 import { bundleRuntime } from './bundle-runtime.mjs';
 import {withPersistentTransforms} from './transform-cache.mjs';
+import {withCompilationStorage,configureCompilationStorage} from './compilation-storage.mjs';
+import {reclaimBuildStages,trackBuildStage} from './build-retention.mjs';
 import {applicationEntry, frameworkImportName, frameworkRuntimeImportPattern} from './framework-imports.mjs';
 import { expandLocales, localizedStaticPaths } from './i18n.mjs';
 import { build as bundle, withCompilation, configureCompiler, compilerSource,buildAnalysisRecords,buildAnalysisRoutes,devDependencies,devStylePlans,devStyleDependencies,devModules,readCompilerFile,compilationGraphCacheReport } from './compiler.mjs';
 import {retainDeploymentAssets} from './deployment-assets.mjs';
 import {selectHtmlOnlyRoutes} from './html-only-config.mjs';
 import {writeBuildAnalysis} from './analyze.mjs';
+import {prepareNativePprShells} from './native-ppr.mjs';
 import {routeFiles} from './dev-discovery.mjs';
 import {tryBuildLazyGraph,rememberLazyBuildContext,forgetLazyBuildContext} from './dev-lazy-build.mjs';
 import {writeTypedRoutes} from './typed-routes.mjs';
@@ -37,7 +40,7 @@ import { compileCustomRoutes } from './custom-routes.mjs';
 import { compileMiddleware } from './middleware.mjs';
 import { prepareScriptWorkers } from './script-workers.mjs';
 import { prepareMetadataRoutes } from './metadata-routes.mjs';
-import { prepareImageResponse } from './og.mjs';
+import { prepareImageResponse, imageResponseRequirement } from './og.mjs';
 import { prepareCacheHandler, prepareCacheHandlers } from './cache-handlers.mjs';
 import { npmPackagesPlugin } from './npm-packages.mjs';
 import { createRefreshTransform, createSourceLocationTransform, devSingletonsPlugin, devClientFile } from './dev.mjs';
@@ -74,7 +77,7 @@ async function copyRuntimeFiles(stage,{development=true}={}) {
   if (failed) throw failed.reason;
 }
 
-function compatibilityPlugin({ browser, pageFiles, projectRoot, documentFile, serverOnlyFiles, fonts, refresh, locations, reactCompiler }) {
+function compatibilityPlugin({ browser, pageFiles, projectRoot, documentFile, serverOnlyFiles, fonts, refresh, locations, reactCompiler, nativeCompiler = false }) {
   return {
     name: 'prnext-pages-compatibility',
     setup(esbuild) {
@@ -108,8 +111,13 @@ function compatibilityPlugin({ browser, pageFiles, projectRoot, documentFile, se
         // loaders. Keep that entire graph original: an uppercase JSX utility
         // may be called normally there, outside a React render. Browser render
         // graphs receive memoization before instrumentation and JSX lowering.
-        const compiled=browser && reactCompiler && args.path!==documentFile && !serverOnlyFiles.has(args.path) ? await reactCompiler(original,args.path,{loaderOutput:args.prnextSource!==undefined}) : original;
-        const source = await fonts.transform(locations?await locations(compiled,args.path):compiled, args.path);
+        const compile = browser && reactCompiler && args.path!==documentFile && !serverOnlyFiles.has(args.path);
+        // Oxc can hoist static JSX without a source-map position. Attach the
+        // same original inspector attributes as SSR before that transformation.
+        const locateFirst = !!(compile && nativeCompiler && locations);
+        const input = locateFirst ? await locations(original,args.path) : original;
+        const compiled = compile ? await reactCompiler(input,args.path,{loaderOutput:args.prnextSource!==undefined}) : input;
+        const source = await fonts.transform(locations && !locateFirst ? await locations(compiled,args.path) : compiled, args.path);
         assertSupportedSource(source, args.path);
         const dynamicSource = transformDynamicImports(source, args.path, { projectRoot, mode: browser ? 'browser' : 'server' });
         let contents = browser && pageFiles.has(args.path) ? stripServerCode(dynamicSource, args.path) : dynamicSource;
@@ -179,8 +187,9 @@ export function build(projectRoot, options = {}) {
     const envMode = options.envMode || (process.env.NODE_ENV === 'test' ? 'test' : options.dev ? 'development' : 'production');
     process.env.NODE_ENV = options.dev ? 'development' : 'production';
     try { return await withBuildLock(projectRoot, async root => {
+      await reclaimBuildStages(root);
       const started=performance.now();
-      const result=await withPersistentTransforms(root,{dev:!!options.dev},()=>withCompilation(() => buildProject(root, { ...options, envMode })));
+      const result=await withCompilationStorage(root,()=>withPersistentTransforms(root,{dev:!!options.dev},()=>withCompilation(() => buildProject(root, { ...options, envMode }))));
       return {...result,durationMs:Math.round(performance.now()-started)};
     }); }
     finally { restore(); }
@@ -198,9 +207,10 @@ async function buildProject(projectRoot, { dev = false, envMode, incremental = f
     if (deferred) return deferred;
   }
   const config = await loadProjectConfig(projectRoot, { dev, envMode, devInputs });
+  configureCompilationStorage(config.compilationCache);
   const tsconfig = config.typescript ? await projectTsconfig(projectRoot, config) : undefined;
   const environment = defineEnvironment(config);
-  const publicPaths = { trailingSlash: config.trailingSlash, skipTrailingSlashRedirect: config.skipTrailingSlashRedirect, basePath: config.basePath, assetPrefix: config.assetPrefix, assetBase: publicAssetBase(config) };
+  const publicPaths = { server: config.server, trailingSlash: config.trailingSlash, skipTrailingSlashRedirect: config.skipTrailingSlashRedirect, basePath: config.basePath, assetPrefix: config.assetPrefix, assetBase: publicAssetBase(config) };
   const customRoutes = await compileCustomRoutes(config);
   const buildId = await generateBuildId(config, { dev });
   const scanOptions={basePath:config.basePath,pageExtensions:config.pageExtensions,i18n:config.i18n};
@@ -222,12 +232,14 @@ async function buildProject(projectRoot, { dev = false, envMode, incremental = f
   const stage = path.join(project.root, `.prnext-build-${randomUUID()}`);
   const destination = await prepareBuildDirectory(project.root, config.distDir);
   const backup = path.join(project.root, `.prnext-backup-${randomUUID()}`);
+  const recovery=await trackBuildStage(project.root,{stage,backup}).catch(()=>null);
+  try {
   await mkdir(path.join(stage, '.entries'), { recursive: true });
   await mkdir(path.join(stage, 'static'), { recursive: true });
   await addBuiltinPagesErrors(project, stage);
   const manifest = { version: 1, dev, buildId, cacheId: randomUUID(), previewModeId: randomUUID().replaceAll('-', ''), previewModeEncryptionKey: randomBytes(32).toString('hex'),
     ...(dev && Array.isArray(devRoutes) ? {devOnDemand:true} : {}), ...(dev && devSession ? {devSequence,devSession} : {}), ...(dev ? {devForceRefresh,devAffectedModules,devIndicators:config.devIndicators,...(devTools?{devTools}:{})} : {}),
-    config: { i18n: config.i18n, skipMiddlewareUrlNormalize: config.skipMiddlewareUrlNormalize, compress: config.compress, poweredByHeader: config.poweredByHeader, reactStrictMode: config.reactStrictMode, cacheComponents: config.cacheComponents, partialPrefetching: config.partialPrefetching, navigationCache: config.navigationCache, cacheLife: config.cacheLife, htmlOnly:config.htmlOnly, images: config.images, ...publicPaths }, customRoutes, routes: [], prerendered: [],
+    config: { i18n: config.i18n, skipMiddlewareUrlNormalize: config.skipMiddlewareUrlNormalize, compress: config.compress, poweredByHeader: config.poweredByHeader, reactStrictMode: config.reactStrictMode, cacheComponents: config.cacheComponents, partialPrefetching: config.partialPrefetching, navigationCache: config.navigationCache, cacheLife: config.cacheLife, htmlOnly:config.htmlOnly, images: config.images, streamingRequestBodies: config.experimental.streamingRequestBodies, nativePprShell: config.experimental.nativePprShell, ...publicPaths }, customRoutes, routes: [], prerendered: [],
     ...(project.pagesErrors ? { pagesErrors: project.pagesErrors } : {}) };
   // Its build-unique name is known before bundling and avoids a hash cycle
   // between page entry URLs and the manifest that lists those entries.
@@ -250,7 +262,6 @@ async function buildProject(projectRoot, { dev = false, envMode, incremental = f
     // Runtime copies must work even when dotenv is nested beneath the PRNext
     // package instead of hoisted beside the application's dependencies.
     await bundle({ entryPoints: [path.join(packageRoot, 'runtime/env.mjs')], outfile: path.join(stage, 'runtime/env.mjs'), bundle: true, platform: 'node', format: 'esm', target: 'node22', logLevel: 'silent', banner: { js: "import {createRequire as __prnextCreateRequire} from 'node:module';const require=__prnextCreateRequire(import.meta.url);" } });
-    await prepareImageResponse(stage);
     manifest.config.serverActions = config.experimental.serverActions;
     if(config.workerMemory && !dev)manifest.config.workerMemory=config.workerMemory;
     if (config.workerRetirement) manifest.config.workerRetirement = config.workerRetirement;
@@ -295,7 +306,7 @@ async function buildProject(projectRoot, { dev = false, envMode, incremental = f
       }
     }
     if (Object.keys(clientEntries).length) {
-      const browser = await bundle({ ...common, entryPoints: clientEntries, outdir: path.join(stage, 'assets'), entryNames: '[name]-[hash]', chunkNames: 'chunk-[hash]', platform: 'browser', format: 'esm', target: ['es2022'], splitting: true, minify: !dev, sourcemap: dev || config.productionBrowserSourceMaps, define: { 'process.env': '{}', ...common.define }, plugins: [moduleResolutionPlugin(config.turbopack, project.root), ...(dev ? [devSingletonsPlugin()] : []), images.plugin(), fonts.plugin(), compatibilityPlugin({ browser: true, pageFiles, projectRoot: project.root, documentFile: project.document, serverOnlyFiles, fonts, refresh, locations, reactCompiler }), cssModules.plugin(true)] });
+      const browser = await bundle({ ...common, entryPoints: clientEntries, outdir: path.join(stage, 'assets'), entryNames: '[name]-[hash]', chunkNames: 'chunk-[hash]', platform: 'browser', format: 'esm', target: ['es2022'], splitting: true, minify: !dev, sourcemap: dev || config.productionBrowserSourceMaps, define: { 'process.env': '{}', ...common.define }, plugins: [moduleResolutionPlugin(config.turbopack, project.root), ...(dev ? [devSingletonsPlugin()] : []), images.plugin(), fonts.plugin(), compatibilityPlugin({ browser: true, pageFiles, projectRoot: project.root, documentFile: project.document, serverOnlyFiles, fonts, refresh, locations, reactCompiler, nativeCompiler: config.reactCompiler?.backend === 'oxc' }), cssModules.plugin(true)] });
       fonts.record(browser.metafile);
       const byEntry = new Map(Object.entries(clientEntries).map(([id, file]) => [path.resolve(file), id]));
       for (const [output, metadata] of Object.entries(browser.metafile.outputs)) {
@@ -312,7 +323,7 @@ async function buildProject(projectRoot, { dev = false, envMode, incremental = f
     await compileMiddleware({ project, stage, manifest, dev, moduleResolution: config.turbopack, defineEnvironment: environment });
     if (manifest.middleware) manifest.middleware.bodySizeLimit = config.experimental.proxyClientMaxBodySize;
     await prepareMetadataRoutes(project, stage);
-    await compileApp({ project, stage, manifest, reactCompiler: config.reactCompiler, moduleResolution: config.turbopack, cssModules, fonts, images, dev, devActionSecret:dev?devActionSecret:undefined, defineEnvironment: environment, productionBrowserSourceMaps: config.productionBrowserSourceMaps, serverExternalPackages: config.serverExternalPackages, lazyDynamicImports:dev&&config.experimental.lazyDynamicImports,devLazyRequest,devLazyActivated });
+    await compileApp({ project, stage, manifest, reactCompiler: config.reactCompiler, moduleResolution: config.turbopack, cssModules, fonts, images, dev, devActionSecret:dev?devActionSecret:undefined, defineEnvironment: environment, productionBrowserSourceMaps: config.productionBrowserSourceMaps, serverExternalPackages: config.serverExternalPackages, lazyDynamicImports:dev&&config.experimental.lazyDynamicImports,devLazyRequest,devLazyActivated, parallelBuilds: !dev && config.experimental.parallelBuilds && await cssModules.parallelSafe() ? config.experimental.parallelBuilds : false });
     if(manifest.devLazy){
       const css=Object.values(manifest.devLazy.outputs).flatMap(module=>module.css);
       for(const route of manifest.routes)if(route.router==='app'&&route.kind==='page'){
@@ -338,14 +349,18 @@ async function buildProject(projectRoot, { dev = false, envMode, incremental = f
     await checkTypeScript(project.root, config, { dev, tsconfig });
     fonts.attach(manifest);
     expandLocales(manifest);
+    const imageResponse = await imageResponseRequirement(stage, {dev, manifest});
+    if (imageResponse.included) await prepareImageResponse(stage);
+    else await rm(path.join(stage, 'compat/og.cjs'), {force: true});
     // All runtime preparation must finish before its shared modules are built;
     // no staged renderer has been imported before this production-only point.
-    if (!dev) await bundleRuntime(stage,{projectRoot:project.root,sourceDirectory:path.join(packageRoot,'runtime')});
+    if (!dev) await bundleRuntime(stage,{projectRoot:project.root,sourceDirectory:path.join(packageRoot,'runtime'),imageResponse:imageResponse.included});
     // Node caches CJS React by filename, not NODE_ENV. Once development metadata
     // imports load it, subsequent production renders need a clean process too.
     if(dev) developmentModulesLoaded = true;
     if(!dev) Object.assign(manifest,await (incremental || developmentModulesLoaded ? isolatedPrerender : prerenderProduction)(project.root,stage,manifest,{prerender:config.prerender}));
     else {await prerender(stage, manifest, dev);await prerenderApp(stage, manifest, dev);}
+    if (!dev) await prepareNativePprShells(stage, manifest);
     const pages = manifest.routes.filter(route => route.kind === 'page' && route.router !== 'app' && !route.internal && !route.devDeferred);
     const publicPage = route => ({ ...(route.locale ? {locale:route.locale,originalPattern:route.originalPattern} : {}), id: route.id, pattern: route.pattern, client: route.client, css: route.css, ...(route.fonts ? { fonts: route.fonts } : {}), ssg: !!route.ssg, ssp: !!route.ssp, gip: !!route.gip, appGip: !!route.appGip });
     if (pages.length || manifest.pagesErrors) {
@@ -420,12 +435,14 @@ async function buildProject(projectRoot, { dev = false, envMode, incremental = f
       throw error;
     } finally { await rm(pointerTemporary, {force:true}); }
     await exported?.commit();
-    if (hadDestination) await rm(backup, { recursive: true, force: true });
+    await recovery?.committed().catch(()=>{});
+    if(!recovery&&hadDestination)await rm(backup,{recursive:true,force:true});
     if(dev&&!devLazyRequest)rememberLazyBuildContext(project.root,{manifest,config,environment,tsconfig,envMode});
     return { ...manifest, outputDirectory: destination, durationMs: Math.round(performance.now() - started),reactCompilerReport:compilerReport,compilationCache };
   } catch (error) {
-    await rm(stage, { recursive: true, force: true });
+    if(!recovery)await rm(stage, { recursive: true, force: true });
     if (error.errors) error.message = error.errors.map(item => `${item.location ? `${item.location.file}:${item.location.line}: ` : ''}${item.text}`).join('\n');
     throw error;
   }
+  }finally{await recovery?.cleanup();}
 }

package/build/native-ppr.mjs

@@ -0,0 +1,32 @@
+import {readFile, writeFile, stat} from 'node:fs/promises';
+import path from 'node:path';
+import {partialShell, sha256, NATIVE_PPR_ARTIFACT_BYTES, NATIVE_PPR_PREFIX_BYTES} from '../runtime/native-ppr.mjs';
+
+// Only concrete build-time shells are certified. Runtime regeneration, generic
+// params, middleware and external caches stay on the authoritative Node path.
+export async function prepareNativePprShells(stage, manifest) {
+  delete manifest.config.nativePprArtifacts;
+  if (!manifest.config.nativePprShell || !manifest.config.cacheComponents || manifest.dev || manifest.middleware || manifest.config.basePath || manifest.config.cacheHandler || Object.keys(manifest.config.cacheHandlers || {}).length) return;
+  const descriptors = [];
+  let total = 0;
+  for (const route of [...manifest.routes].sort((a, b) => a.id.localeCompare(b.id))) {
+    if (route.kind !== 'page' || route.router !== 'app' || route.internal || route.parallel || route.cacheConfig?.runtime === 'edge') continue;
+    for (const [pathname, artifactFile] of Object.entries(route.ppr || {}).sort(([a], [b]) => a.localeCompare(b))) {
+      if (descriptors.length >= 32) break;
+      const file = path.resolve(stage, artifactFile);
+      if (!artifactFile.startsWith('static/') || !file.startsWith(path.resolve(stage) + path.sep) || (await stat(file)).size > NATIVE_PPR_ARTIFACT_BYTES) continue;
+      const bytes = await readFile(file);
+      const artifact = JSON.parse(bytes);
+      if (artifact.version !== 1 || !artifact.postponed || artifact.complete || artifact.generic || artifact.externalCache || artifact.revalidate === 0 || typeof artifact.flight !== 'string' || Object.keys(artifact.headers || {}).length) continue;
+      const prefix = Buffer.from(partialShell(artifact, route).replace(/<\/body><\/html>$/i, ''));
+      if (prefix.length > NATIVE_PPR_PREFIX_BYTES || total + prefix.length > 4 * 1024 * 1024) continue;
+      if (!Number.isSafeInteger(artifact.generatedAt) || artifact.generatedAt < 0 || !(artifact.revalidate == null || artifact.revalidate === false || Number.isSafeInteger(artifact.revalidate) && artifact.revalidate > 0)) continue;
+      const prefixHash = sha256(prefix);
+      const prefixFile = `static/native-ppr-${prefixHash}.html`;
+      await writeFile(path.join(stage, prefixFile), prefix);
+      descriptors.push({routeId: route.id, path: pathname, artifact: artifactFile, artifactHash: sha256(bytes), prefix: prefixFile, prefixHash, identity: sha256(artifact.flight), generatedAt: artifact.generatedAt, revalidate: artifact.revalidate ?? false});
+      total += prefix.length;
+    }
+  }
+  manifest.config.nativePprArtifacts = descriptors;
+}

package/build/og.mjs

@@ -1,6 +1,126 @@
-import { cp, mkdir } from 'node:fs/promises';
+import { cp, mkdir, readdir, lstat, open } from 'node:fs/promises';
 import { fileURLToPath } from 'node:url';
 import path from 'node:path';
+import { builtinModules } from 'node:module';
+import { analyzeSource } from './source-analysis.mjs';
+
+const packageRoot = fileURLToPath(new URL('../', import.meta.url));
+const inside = (root, file) => file === root || file.startsWith(root + path.sep);
+const builtins = new Set([...builtinModules, ...builtinModules.map(name => 'node:' + name)]);
+const unsafeBuiltins = /^(?:node:)?(?:vm|worker_threads|child_process)$/;
+const react = /^(?:react|react-dom|react-server-dom-webpack)(?:\/|$)/;
+const maxFiles = 4096, maxBytes = 64 * 1024 * 1024, maxFileBytes = 8 * 1024 * 1024;
+
+/** Certification examines the actual emitted server graph, never source-text
+ * matches. An unknown loader/dependency is an inclusion, not an omission. The
+ * installed framework modules are a fixed boundary; application graph roots,
+ * middleware, instrumentation, cache handlers and client SSR are all inspected. */
+export async function imageResponseRequirement(stage, {dev = false, manifest = {}} = {}) {
+  const included = reason => ({included: true, reason});
+  if (dev) return included('development');
+  if (manifest.middleware?.runtime === 'edge' || manifest.routes?.some(route => route.handlerConfig?.runtime === 'edge' || route.cacheConfig?.runtime === 'edge')) return included('edge-runtime');
+  stage = path.resolve(stage);
+  const pending = [], seen = new Set();
+  let bytes = 0;
+  try {
+    for (const name of ['server', 'app-ssr', 'app-ssr-edge']) {
+      const directory = path.join(stage, name);
+      let entries;
+      try { const info = await lstat(directory); if (!info.isDirectory() || info.isSymbolicLink()) return included('unverified-output'); entries = await readdir(directory, {withFileTypes: true}); }
+      catch (error) { if (error.code === 'ENOENT') continue; throw error; }
+      if (entries.some(entry => !entry.isFile())) return included('unverified-output');
+      for (const entry of entries) if (/\.(?:[cm]?js)$/.test(entry.name)) pending.push(path.join(directory, entry.name));
+    }
+    for (const entry of [manifest.middleware?.module, manifest.config?.cacheHandler, ...Object.values(manifest.config?.cacheHandlers || {})]) if (entry) pending.push(path.resolve(stage, entry));
+    while (pending.length) {
+      const file = pending.pop();
+      if (seen.has(file)) continue;
+      if (!inside(stage, file) || seen.size >= maxFiles) return included('unverified-output');
+      seen.add(file);
+      // An actual application import of the compatibility layer or loader is
+      // sufficient evidence, even if the ImageResponse binding is only dynamic.
+      if (file === path.join(stage, 'compat/og.cjs') || file === path.join(stage, 'runtime/og-loader.mjs') || inside(path.join(stage, 'runtime/og'), file)) return included('image-response-import');
+      const relative = path.relative(stage, file);
+      const frameworkFile = relative.startsWith('compat' + path.sep) || relative.startsWith('runtime' + path.sep);
+      if (frameworkFile) {
+        // Only exact installed files are trusted. Configured output overrides
+        // and missing/unknown framework modules retain the complete renderer.
+        const known = path.join(packageRoot, relative), [a, b] = await Promise.all([lstat(file), lstat(known)]);
+        if (!a.isFile() || a.isSymbolicLink() || !b.isFile() || b.isSymbolicLink() || a.size !== b.size) return included('unverified-framework');
+        const [actual, expected] = await Promise.all([readBounded(file, maxFileBytes), readBounded(known, maxFileBytes)]);
+        if (!actual.equals(expected)) return included('unverified-framework');
+        continue;
+      }
+      const info = await lstat(file);
+      if (!info.isFile() || info.isSymbolicLink() || info.size > maxFileBytes || (bytes += info.size) > maxBytes) return included('unverified-output');
+      const source = await readBounded(file, maxFileBytes), analysis = analyzeSource(source.toString(), file);
+      if (hasUnknownLoading(analysis.program)) return included('dynamic-loader');
+      for (const dependency of analysis.imports) {
+        const specifier = dependency.path;
+        if (typeof specifier !== 'string' || specifier.includes('\0') || unsafeBuiltins.test(specifier)) return included('unverified-dependency');
+        if (builtins.has(specifier) || react.test(specifier)) continue;
+        if (/^(?:next|prnext|@thomas\.f\/prnext)\/og(?:\.js)?$/.test(specifier)) return included('image-response-import');
+        if (!specifier.startsWith('.')) return included('external-dependency');
+        const target = path.resolve(path.dirname(file), specifier);
+        // JSON/data imports cannot load executable OG code. Other extensions
+        // and extensionless resolution are deliberately not guessed.
+        if (target.endsWith('.json')) {
+          if (!inside(stage, target) || !(await lstat(target)).isFile()) return included('unverified-dependency');
+          continue;
+        }
+        if (!/\.(?:[cm]?js)$/.test(target)) return included('unverified-dependency');
+        pending.push(target);
+      }
+    }
+    return {included: false, reason: 'certified-unused', files: seen.size, bytes};
+  } catch { return included('unverified-output'); }
+}
+
+async function readBounded(filename, limit) {
+  const file = await open(filename, 'r');
+  try {
+    const before = await file.stat();
+    if (!before.isFile() || before.size > limit) throw Error('ImageResponse graph exceeds its file budget');
+    const buffer = Buffer.alloc(before.size + 1);
+    let length = 0;
+    while (length < buffer.length) { const next = await file.read(buffer, length, buffer.length - length, null); if (!next.bytesRead) break; length += next.bytesRead; }
+    const after = await file.stat();
+    if (length !== before.size || before.size !== after.size || before.mtimeMs !== after.mtimeMs || before.ctimeMs !== after.ctimeMs) throw Error('ImageResponse graph changed during certification');
+    return buffer.subarray(0, length);
+  } finally { await file.close(); }
+}
+
+function hasUnknownLoading(program) {
+  const factories = new Set(program.body.filter(node => node.type === 'ImportDeclaration' && ['module', 'node:module'].includes(node.source?.value)).flatMap(node => node.specifiers.filter(item => item.type === 'ImportSpecifier' && item.imported?.name === 'createRequire').map(item => item.local.name)));
+  const stack = [[program, null]];
+  while (stack.length) {
+    const [node, parent] = stack.pop();
+    if (node.type === 'Identifier' && (['eval', 'Function', 'Reflect'].includes(node.name) || /webpack_require/.test(node.name))) return true;
+    if (node.type === 'MemberExpression' && (node.property?.name ?? node.property?.value) === 'constructor') return true;
+    if (node.type === 'ImportExpression' && typeof node.source?.value !== 'string') return true;
+    if ((node.type === 'NewExpression' || node.type === 'CallExpression') && (node.callee?.name === 'eval' || node.callee?.name === 'Function' || ['eval', 'Function', 'constructor', 'runInContext', 'runInNewContext', 'compileFunction', 'dlopen', 'getBuiltinModule'].includes(node.callee?.property?.name ?? node.callee?.property?.value))) return true;
+    if (node.type === 'CallExpression' && factories.has(node.callee?.name) && (parent?.type !== 'VariableDeclarator' || parent.id?.name !== 'require')) return true;
+    if (node.type === 'ImportDeclaration' && ['module', 'node:module'].includes(node.source?.value) && node.specifiers.some(item => item.type !== 'ImportSpecifier' || item.imported?.name !== 'createRequire')) return true;
+    if (node.type === 'Identifier' && /^_*require\d*$/.test(node.name)) {
+      const binding = parent?.type === 'VariableDeclarator' && parent.id === node && parent.init?.type === 'CallExpression' && factories.has(parent.init.callee?.name);
+      const call = node.name === 'require' && parent?.type === 'CallExpression' && parent.callee === node;
+      if (!binding && (!call || parent.arguments.length !== 1 || typeof parent.arguments[0]?.value !== 'string')) return true;
+    }
+    if (node.type === 'CallExpression' && node.callee?.type === 'MemberExpression' && ['require', '_load', 'createRequire'].includes(node.callee.property?.name)) return true;
+    if (node.type === 'Identifier' && factories.has(node.name)) {
+      const specifier = parent?.type === 'ImportSpecifier';
+      const call = parent?.type === 'CallExpression' && parent.callee === node && parent.arguments.length === 1 && parent.arguments[0]?.type === 'MemberExpression' && parent.arguments[0].object?.type === 'MetaProperty' && parent.arguments[0].property?.name === 'url';
+      if (!specifier && !call) return true;
+    }
+    if (node.type === 'VariableDeclarator' && node.init?.type === 'CallExpression' && factories.has(node.init.callee?.name) && node.id?.name !== 'require') return true;
+    for (const value of Object.values(node)) {
+      if (Array.isArray(value)) { for (const item of value) if (item?.type) stack.push([item, node]); }
+      else if (value?.type) stack.push([value, node]);
+    }
+  }
+  return false;
+}
+
 export async function prepareImageResponse(stage) {
   const target = path.join(stage, 'runtime/og');
   await mkdir(target, { recursive: true });

package/build/parallel-plan.mjs

@@ -0,0 +1,55 @@
+import {availableParallelism, freemem} from 'node:os';
+import {mapConcurrent} from './concurrent.mjs';
+import {mkdir, writeFile} from 'node:fs/promises';
+import path from 'node:path';
+import {createHash} from 'node:crypto';
+
+// Budget admission, not a claim to cap esbuild/PostCSS process RSS. A single
+// heavy custom transform can exceed its estimate, so unknown hooks stay serial.
+export function buildPlanConcurrency(options, {cpus = availableParallelism(), freeBytes = freemem()} = {}) {
+  if (!options) return 1;
+  return Math.max(1, Math.min(options.maxWorkers, cpus, Math.floor(options.maxMemoryMb / 256), Math.floor(freeBytes / (512 * 1024 * 1024))));
+}
+
+export function immutableStylePlan(routes, getPlan) {
+  const jobs = new Map();
+  const plannedRoutes = routes.map(route => Object.freeze({id: route.id, parallel: !!route.parallel,
+    scopes: Object.freeze(getPlan(route).map(scope => {
+      const styles = Object.freeze([...scope.styles]);
+      const signature = JSON.stringify(styles);
+      if (!jobs.has(signature)) jobs.set(signature, Object.freeze({signature, styles}));
+      return Object.freeze({signature, path: scope.path, kind: scope.kind});
+    })),
+  }));
+  return Object.freeze({routes: Object.freeze(plannedRoutes), jobs: Object.freeze([...jobs.values()])});
+}
+
+export async function executeStylePlan(plan, run, options) {
+  const concurrency = buildPlanConcurrency(options);
+  const outputs = await mapConcurrent(plan.jobs, run, concurrency);
+  return {outputs: new Map(plan.jobs.map((job, index) => [job.signature, outputs[index]])), concurrency};
+}
+
+// Independent CSS graphs can emit the same url() asset. Compile in parallel,
+// but publish each exact output once. Keep only hashes and settled promises,
+// not all completed bundles, so memory stays bounded by admitted jobs.
+export function createStyleOutputWriter(directory) {
+  const root = path.resolve(directory), outputs = new Map();
+  return async files => {
+    for (const file of files) {
+      const target = path.resolve(file.path), relative = path.relative(root, target);
+      if (!relative || relative === '..' || relative.startsWith('..' + path.sep) || path.isAbsolute(relative)) throw new Error('Style output escaped its build directory');
+      const key = process.platform === 'win32' ? target.toLowerCase() : target;
+      const hash = createHash('sha256').update(file.contents).digest('hex');
+      const previous = outputs.get(key);
+      if (previous) {
+        if (previous.hash !== hash) throw new Error(`Conflicting style output: ${relative}`);
+        await previous.written;
+      } else {
+        const written = (async () => {await mkdir(path.dirname(target), {recursive: true}); await writeFile(target, file.contents);})();
+        outputs.set(key, {hash, written});
+        await written;
+      }
+    }
+  };
+}

package/build/persistent-cache.mjs

@@ -6,10 +6,15 @@ import {open,lstat,mkdir,realpath,readFile,readdir,rename,unlink} from 'node:fs/
 import path from 'node:path';
 import {fileURLToPath} from 'node:url';
 import {createRequire} from 'node:module';
+import {deflateRaw,inflateRaw} from 'node:zlib';
+import {promisify} from 'node:util';
+export {pruneCompilerCache} from '../runtime/compile-cache-retention.mjs';
 
 export const cacheHash=value=>createHash('sha256').update(value).digest('hex');
 const packageRoot=fileURLToPath(new URL('../',import.meta.url)),require=createRequire(import.meta.url);
 const MAX_DISK=64*1024*1024;
+const compress=promisify(deflateRaw),decompress=promisify(inflateRaw);
+const MAGIC=Buffer.from('PRNC2\0'),HEADER=MAGIC.length+4+32+32;
 let frameworkIdentity;
 async function frameworkHash(){
   frameworkIdentity??=(async()=>{
@@ -59,45 +64,45 @@ export async function privateCacheDirectory(root,kind){
     return directory;
   }catch{return null;}
 }
-/** Best-effort V8 cache retention; never follow links or traverse app sources. */
-export async function pruneCompilerCache(directory,{maxBytes=64*1024*1024,maxFiles=2048}={}){
-  if(!directory)return;
-  try{
-    const files=[];let scanned=0;
-    async function collect(folder,depth){
-      if(depth>3||scanned>=8192)return;
-      for(const entry of await readdir(folder,{withFileTypes:true})){
-        if(++scanned>8192)break;
-        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);
-        else if(info.isFile())files.push({name,size:info.size,time:info.mtimeMs});
-      }
-    }
-    const info=await lstat(directory);if(!info.isDirectory()||info.isSymbolicLink())return;
-    await collect(directory,0);files.sort((a,b)=>b.time-a.time);let bytes=0;
-    for(let i=0;i<files.length;i++){bytes+=files[i].size;if(i>=maxFiles||bytes>maxBytes)await unlink(files[i].name).catch(()=>{});}
-  }catch{/* Optional caches must never prevent compilation. */}
-}
 export async function readCacheRecord(directory,key,limit=16*1024*1024){
-  if(!directory||!/^[a-f0-9]{64}$/.test(key))return null;
+  if(!directory||!/^[a-f0-9]{64}$/.test(key)||!Number.isSafeInteger(limit)||limit<1||limit>64*1024*1024)return null;
   let file;
   try{
     const name=path.join(directory,key+'.json'),info=await lstat(name);
     if(!info.isFile()||info.isSymbolicLink()||info.size>limit)return null;
     file=await open(name,fsConstants.O_RDONLY|(fsConstants.O_NOFOLLOW||0));
     const stat=await file.stat();if(!stat.isFile()||stat.size>limit)return null;
-    const record=JSON.parse(await file.readFile('utf8'));
+    const body=await file.readFile();
+    if(body.subarray(0,MAGIC.length).equals(MAGIC)){
+      if(body.length<HEADER)return null;
+      const size=body.readUInt32BE(MAGIC.length);
+      if(size>limit||body.subarray(MAGIC.length+4,MAGIC.length+36).toString('hex')!==key)return null;
+      const payload=await decompress(body.subarray(HEADER),{maxOutputLength:Math.max(1,size)});
+      if(payload.length!==size||cacheHash(payload)!==body.subarray(MAGIC.length+36,HEADER).toString('hex'))return null;
+      return JSON.parse(payload.toString('utf8'));
+    }
+    const record=JSON.parse(body.toString('utf8'));
     if(record.version!==1||record.key!==key||typeof record.payload!=='string'||cacheHash(record.payload)!==record.checksum)return null;
     return JSON.parse(record.payload);
   }catch{return null;}finally{await file?.close().catch(()=>{});}
 }
 export async function writeCacheRecord(directory,key,value,limit=16*1024*1024,{maxFiles=64}={}){
-  if(!directory||!/^[a-f0-9]{64}$/.test(key))return false;
+  if(!directory||!/^[a-f0-9]{64}$/.test(key)||!Number.isSafeInteger(limit)||limit<1||limit>64*1024*1024)return false;
   if(!Number.isInteger(maxFiles)||maxFiles<1||maxFiles>4096)return false;
   const filename=path.join(directory,key+'.json'),temporary=filename+'.'+randomUUID()+'.tmp';
   try{
-    const payload=JSON.stringify(value),body=JSON.stringify({version:1,key,checksum:cacheHash(payload),payload});
+    const payload=JSON.stringify(value);if(payload===undefined||Buffer.byteLength(payload)>limit)return false;
+    let body=JSON.stringify({version:1,key,checksum:cacheHash(payload),payload});
+    // Large, repetitive JSON benefits from one encoding instead of embedding a
+    // second escaped JSON string. Keep small records compatible with v1.
+    if(Buffer.byteLength(payload)>=16384){
+      const bytes=Buffer.from(payload),packed=await compress(bytes,{level:1});
+      if(packed.length+HEADER<bytes.length*0.9){
+        const header=Buffer.alloc(HEADER);MAGIC.copy(header);header.writeUInt32BE(bytes.length,MAGIC.length);
+        Buffer.from(key,'hex').copy(header,MAGIC.length+4);Buffer.from(cacheHash(bytes),'hex').copy(header,MAGIC.length+36);
+        body=Buffer.concat([header,packed]);
+      }
+    }
     if(Buffer.byteLength(body)>limit)return false;
     const file=await open(temporary,'wx',0o600);try{await file.writeFile(body);}finally{await file.close();}
     await rename(temporary,filename);

package/build/production-check.mjs

@@ -0,0 +1,34 @@
+import {isIP} from 'node:net';
+
+/** Configuration checks only: external proxies, databases and sessions need live tests. */
+export function productionDiagnostics(config,project,{env=process.env}={}){
+  const diagnostics=[];
+  const locations={'production-static':'output','production-origin':'server.publicOrigin','production-origin-https':'server.publicOrigin','production-proxy':'server.trustedProxies','production-proxy-range':'server.trustedProxies','production-auth-cookies':'navigationCache.authCookies','production-action-origins':'experimental.serverActions.allowedOrigins','production-source-maps':'productionBrowserSourceMaps'};
+  const add=(id,severity,message,action,location)=>diagnostics.push({id,code:id,path:location||locations[id]||'production',severity,message,...(action?{action}:{})});
+  if(config.output==='export'){
+    add('production-static','info','Static export does not run the PRNext HTTP server.','Check HTTPS, headers and health checks at the static host.');
+  }else{
+    const origin=config.server?.publicOrigin;
+    if(!origin)add('production-origin','warning','The public server origin is not configured.','Set server.publicOrigin to the public HTTPS origin used by redirects, authentication callbacks and request URLs.');
+    else{
+      const url=new URL(origin),hostname=url.hostname,loopback=hostname==='localhost'||hostname==='[::1]'||(isIP(hostname)===4&&hostname.startsWith('127.'));
+      if(url.protocol!=='https:'&&!loopback)add('production-origin-https','warning','The public server origin uses HTTP.','Use an HTTPS public origin and test secure cookies and authentication callbacks through the real proxy.');
+      else add('production-origin','info','The public server origin is configured.');
+    }
+    if(config.server?.trustedProxies?.length)add('production-proxy','info','Forwarded host and protocol are accepted only from the configured proxy addresses.','Bind the application to the private interface and configure the proxy to replace forwarded headers.');
+    if(config.server?.trustedProxies?.some(value=>/\/0$/.test(value)))add('production-proxy-range','error','A trusted proxy range includes every remote address.','Replace /0 ranges with the exact proxy IP addresses or private CIDRs.');
+  }
+  if(project?.routes.some(route=>route.router==='app')&&config.output!=='export'){
+    if(config.navigationCache?.maxEntries>0&&!config.navigationCache?.authCookies?.length)add('production-auth-cookies','warning','Retained App pages have no explicit authentication cookie names.','For authenticated applications, set navigationCache.authCookies to the exact session cookie names, including secure variants. Test account A → sign out → account B without retaining private drafts.');
+    else if(config.navigationCache?.authCookies?.length)add('production-auth-cookies','info','Authentication cookie changes enable strict retained-page state resets.','Test account A → sign out → account B in the browser; this check does not verify application session behavior.');
+    if(config.experimental?.serverActions?.allowedOrigins?.some(value=>value.includes('*')))add('production-action-origins','warning','Server Actions allow wildcard origin patterns.','Use the narrowest trusted host patterns and test rejected cross-origin mutations.');
+  }
+  const experiments=['nextScriptWorkers','lazyDynamicImports','streamingRequestBodies','nativePprShell','parallelBuilds'].filter(key=>config.experimental?.[key]);
+  if(config.reactCompiler?.backend==='oxc')experiments.push('reactCompiler.backend=oxc');
+  if(config.partialPrefetching)experiments.push('partialPrefetching');
+  if(env.PRNEXT_SSR_STREAM==='node')experiments.push('PRNEXT_SSR_STREAM=node');
+  for(const option of experiments)add('production-experimental','warning',`Experimental option enabled: ${option}.`,'Qualify this exact option on the deployment workload and keep its documented fallback available.',option.includes('=')?option.split('=')[0]:option==='partialPrefetching'?option:'experimental.'+option);
+  if(config.productionBrowserSourceMaps)add('production-source-maps','warning','Production browser source maps are enabled.','Confirm that exposing original browser sources is intentional.');
+  add('production-validation','info','Configuration preflight does not prove production readiness.','Build the final artifact, test public HTTPS, account changes, health checks, rollback and application dependencies before switching traffic.');
+  return diagnostics;
+}

package/build/react-compiler-report.mjs

@@ -30,9 +30,10 @@ export const withReactCompilerReporting = run => reports.run({ files: new Map(),
 export function configureReactCompilerReporting({ root, config, buildId, dev, compilerVersion }) {
   const state = reports.getStore();
   if (state) Object.assign(state, { root: path.resolve(root), enabled: !!config?.reactCompiler,
-    options: config?.reactCompiler || null, buildId, dev: !!dev, compilerVersion });
+    options: config?.reactCompiler || null, buildId, dev: !!dev, compilerVersion, backend: config?.reactCompiler?.backend || 'babel' });
 }
 export const withReactCompilerGraph = (target, run) => graphs.run(target, run);
+export const reactCompilerGraphTarget = () => graphs.getStore();
 
 /** Capture a narrow, source-free subset of the pinned compiler's public events. */
 export function compilerEvent(event, functions, { moduleOptOut = false, root = '' } = {}) {
@@ -70,7 +71,7 @@ export function recordReactCompilerTransform(file, payload, { cacheHit = false }
   if (!state.files.has(relative) && state.files.size >= FILE_LIMIT) { state.truncated = true; return; }
   let record = state.files.get(relative);
   if (!record) state.files.set(relative, record = { file: relative, transforms: 0, cacheReuses: 0,
-    targets: new Set(), notes: new Set(), functions: new Map() });
+    targets: new Set(), notes: new Set(), functions: new Map(), diagnostics: new Map() });
   record.transforms++; record.cacheReuses += Number(cacheHit);
   const target = graphs.getStore() || 'unspecified';
   record.targets.add(target);
@@ -93,6 +94,16 @@ export function recordReactCompilerTransform(file, payload, { cacheHit = false }
     if (fn.events.size < EVENT_LIMIT && state.eventCount < TOTAL_EVENT_LIMIT) { fn.events.set(detailKey, { ...detail, targets: new Set([target]) }); state.eventCount++; }
     else state.truncated = true;
   }
+  // Oxc reports native diagnostics, not function-success events. Keep these at
+  // file scope rather than inventing function identities or optimized counts.
+  for (const event of payload.diagnostics || []) {
+    const detail = { kind: event.kind, status: event.status, reason: event.reason, category: event.category };
+    const key = JSON.stringify(detail);
+    if (record.diagnostics.has(key)) { record.diagnostics.get(key).targets.add(target); continue; }
+    if (record.diagnostics.size < EVENT_LIMIT && state.eventCount < TOTAL_EVENT_LIMIT) {
+      record.diagnostics.set(key, { ...detail, targets: new Set([target]) }); state.eventCount++;
+    } else state.truncated = true;
+  }
   if (payload.truncated) state.truncated = true;
 }
 export function recordReactCompilerGraph(result) {
@@ -115,13 +126,14 @@ export function reactCompilerReport() {
   if (!state) return null;
   const files = [...state.files.values()].sort((a, b) => a.file.localeCompare(b.file)).map(file => ({
     file: file.file, transforms: file.transforms, cacheReuses: file.cacheReuses, targets: [...file.targets].sort(), notes: [...file.notes].sort(),
+    diagnostics: [...file.diagnostics.values()].map(({ targets, ...event }) => ({ ...event, targets: [...targets].sort() })),
     functions: [...file.functions.values()].map(fn => ({ name: fn.name, start: fn.start, end: fn.end,
       status: fn.statuses.size === 1 ? [...fn.statuses][0] : 'mixed', targets: [...fn.targets].sort(),
       events: [...fn.events.values()].map(({ targets, ...event }) => ({ ...event, targets: [...targets].sort() })) }))
       .sort((a, b) => (a.start?.line || 0) - (b.start?.line || 0) || (a.start?.column || 0) - (b.start?.column || 0)),
   }));
   const summary = summarize(files);
-  return { version: 1, compilerVersion: state.compilerVersion || null, enabled: !!state.enabled,
+  return { version: 1, backend: state.backend || 'babel', compilerVersion: state.compilerVersion || null, enabled: !!state.enabled,
     buildId: state.buildId || null, mode: state.dev ? 'development' : 'production', scope: 'observed-transforms',
     options: state.enabled ? state.options : null, truncated: state.truncated, summary, files,
     graphs: [...state.graphs.values()].map(graph => ({ target: graph.target, metadataAvailable: graph.metadataAvailable,
@@ -178,9 +190,15 @@ function validReport(report) {
   const targets = value => Array.isArray(value) && value.length <= 4 && value.every(target => ['browser', 'node', 'edge', 'unspecified'].includes(target));
   const validPosition = value => value === null || keys(value, ['line', 'column']) && !!position(value);
   const options = report?.options;
-  const validOptions = options === null || options === true || keys(options, ['compilationMode', 'panicThreshold', 'target'])
+  const validOptions = options === null || options === true || keys(options, ['backend', 'compilationMode', 'panicThreshold', 'target'])
+    && (options.backend === undefined || ['babel', 'oxc'].includes(options.backend))
     && ['infer', 'annotation'].includes(options.compilationMode) && ['none', 'critical_errors', 'all_errors'].includes(options.panicThreshold) && options.target === '19';
-  return keys(report, ['version', 'compilerVersion', 'enabled', 'buildId', 'mode', 'scope', 'options', 'truncated', 'summary', 'files', 'graphs'])
+  const validDiagnostic = event => keys(event, ['kind', 'status', 'reason', 'category', 'targets'])
+    && ['CompileError', 'CompileDiagnostic'].includes(event.kind) && ['error', 'diagnostic'].includes(event.status)
+    && boundedText(event.reason) && boundedText(event.category) && targets(event.targets);
+  return keys(report, ['version', 'backend', 'compilerVersion', 'enabled', 'buildId', 'mode', 'scope', 'options', 'truncated', 'summary', 'files', 'graphs'])
+    && (report.backend === undefined || ['babel', 'oxc'].includes(report.backend))
+    && (report.backend || 'babel') === (options?.backend || 'babel')
     && report.version === 1 && report.scope === 'observed-transforms' && typeof report.enabled === 'boolean' && validOptions
     && typeof report.truncated === 'boolean' && ['development', 'production'].includes(report.mode)
     && boundedText(report.buildId) && boundedText(report.compilerVersion)
@@ -189,8 +207,9 @@ function validReport(report) {
     && Array.isArray(report.files) && report.files.length <= FILE_LIMIT && report.summary.files === report.files.length
     && report.files.every(file => file && typeof file === 'object')
     && new Set(report.files.map(file => file.file)).size === report.files.length
-    && report.files.every(file => keys(file, ['file', 'transforms', 'cacheReuses', 'targets', 'notes', 'functions'])
+    && report.files.every(file => keys(file, ['file', 'transforms', 'cacheReuses', 'targets', 'notes', 'functions', 'diagnostics'])
       && safePath(file.file) && count(file.transforms) && count(file.cacheReuses) && file.cacheReuses <= file.transforms && targets(file.targets)
+      && (file.diagnostics === undefined || Array.isArray(file.diagnostics) && file.diagnostics.length <= EVENT_LIMIT && file.diagnostics.every(validDiagnostic))
       && Array.isArray(file.notes) && file.notes.length <= 16 && file.notes.every(boundedText)
       && Array.isArray(file.functions) && file.functions.length <= FUNCTION_LIMIT && file.functions.every(fn => keys(fn, ['name', 'start', 'end', 'status', 'targets', 'events'])
         && boundedText(fn.name) && statuses.has(fn.status) && validPosition(fn.start) && validPosition(fn.end) && targets(fn.targets)
@@ -208,18 +227,22 @@ function validReport(report) {
 function summarize(files) {
   const summary = { files: files.length, functions: 0, optimized: 0, skipped: 0, errors: 0, diagnostics: 0, mixed: 0, transforms: 0, cacheReuses: 0 };
   for (const file of files) { summary.transforms += file.transforms; summary.cacheReuses += file.cacheReuses;
-    for (const fn of file.functions) { summary.functions++; summary[({ error: 'errors', diagnostic: 'diagnostics' })[fn.status] || fn.status]++; } }
+    for (const fn of file.functions) { summary.functions++; summary[({ error: 'errors', diagnostic: 'diagnostics' })[fn.status] || fn.status]++; }
+    for (const diagnostic of file.diagnostics || []) summary[diagnostic.status === 'error' ? 'errors' : 'diagnostics']++;
+  }
   return summary;
 }
 export function printReactCompilerReport(report, { details = false, log = console.log } = {}) {
   if (!report.enabled) { log('React Compiler: disabled. Enable reactCompiler in the application configuration.'); return; }
   const summary = report.summary;
-  log(`React Compiler ${report.compilerVersion}: ${summary.optimized} optimized, ${summary.skipped} skipped, ${summary.errors} errors, ${summary.diagnostics} diagnostics, ${summary.mixed} mixed.`);
+  if (report.backend === 'oxc') log(`React Compiler oxc ${report.compilerVersion}: function optimization totals unavailable; ${summary.errors} errors, ${summary.diagnostics} diagnostics.`);
+  else log(`React Compiler ${report.compilerVersion}: ${summary.optimized} optimized, ${summary.skipped} skipped, ${summary.errors} errors, ${summary.diagnostics} diagnostics, ${summary.mixed} mixed.`);
   log(`Observed transforms only: ${summary.files} files; ${summary.cacheReuses}/${summary.transforms} transforms reused cached compiler results.${report.truncated ? ' Report truncated at its safety limit.' : ''}`);
   if (report.graphs.some(graph => graph.unobservedInputs || !graph.metadataAvailable)) log('Some graph inputs were not observed by React Compiler; totals do not describe every application component.');
   if (details) for (const file of report.files) {
     log(file.file);
     for (const fn of file.functions) log(`  ${fn.name || '(anonymous)'}${fn.start ? ':' + fn.start.line : ''}: ${fn.status}${fn.events.some(event => event.reason) ? ' — ' + [...new Set(fn.events.map(event => event.reason).filter(Boolean))].join('; ') : ''}`);
+    for (const diagnostic of file.diagnostics || []) log(`  ${diagnostic.status}: ${diagnostic.reason || diagnostic.category || 'Oxc diagnostic'}`);
     for (const note of file.notes) log('  ' + note);
   }
 }