@thomas.f/prnext 0.1.12-alpha → 0.1.13-alpha

package/build/config.mjs

@@ -17,6 +17,8 @@ import { validateI18n } from './i18n.mjs';
 import { frameworkPackages } from './framework-imports.mjs';
 import { validateTypeScript } from './typescript.mjs';
 import { validateWorkerRetirement } from './worker-retirement.mjs';
+import { validateOptimizePackageImports } from './optimize-imports.mjs';
+import { validateProxyBodySize } from './proxy-body-config.mjs';
 
 const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 const configName = /^(?:next|prnext)\.config\.(?:js|mjs|cjs|ts)$/;
@@ -29,6 +31,7 @@ supported.add('turbopack');
 supported.add('i18n');
 supported.add('webpack');
 supported.add('onDemandEntries');
+supported.add('devIndicators');
 for (const key of ['reactCompiler', 'typedRoutes', 'typescript']) supported.add(key);
 for (const key of ['output', 'outputFileTracingRoot', 'outputFileTracingIncludes', 'outputFileTracingExcludes']) supported.add(key);
 
@@ -89,6 +92,7 @@ export function validateProjectConfig(input, filename = 'project config') {
   }
   config.typescript = validateTypeScript(config.typescript);
   config.workerRetirement = validateWorkerRetirement(config.workerRetirement);
+  if (config.devIndicators !== undefined && config.devIndicators !== false) throw new TypeError('devIndicators currently supports only false. PRNext provides development errors and Fast Refresh, but no Next.js development indicator menu.');
   if (config.onDemandEntries !== undefined) {
     const entries = config.onDemandEntries;
     if (!entries || typeof entries !== 'object' || Array.isArray(entries)) throw new TypeError('onDemandEntries must be an object');
@@ -117,14 +121,17 @@ export function validateProjectConfig(input, filename = 'project config') {
     config[key] = [...new Set(names)];
   }
   for (const name of config.transpilePackages) if (config.serverExternalPackages.includes(name)) throw new Error(`${filename}: ${name} cannot be in both transpilePackages and serverExternalPackages.`);
+  // Like Next, retain pg's Node module boundary: its optional pg-native getter
+  // must resolve lazily, not be traversed by the RSC/server bundler at build.
+  if (!config.transpilePackages.includes('pg') && !config.serverExternalPackages.includes('pg')) config.serverExternalPackages.push('pg');
   if (config.sassOptions !== undefined && (!config.sassOptions || typeof config.sassOptions !== 'object' || Array.isArray(config.sassOptions))) throw new Error(`${filename}: sassOptions must be an object.`);
   if (!config.experimental || typeof config.experimental !== 'object' || Array.isArray(config.experimental)) throw new Error(`${filename}: experimental must be an object.`);
   for (const key of Object.keys(config.experimental)) {
-    if (!['nextScriptWorkers', 'serverActions'].includes(key)) throw new Error(`${filename}: experimental.${key} is not supported by PRNext. It cannot be silently ignored.`);
+    if (!['nextScriptWorkers', 'serverActions', 'optimizePackageImports', 'proxyClientMaxBodySize'].includes(key)) throw new Error(`${filename}: experimental.${key} is not supported by PRNext. It cannot be silently ignored.`);
   }
   const nextScriptWorkers = config.experimental.nextScriptWorkers === undefined ? false : config.experimental.nextScriptWorkers;
   if (typeof nextScriptWorkers !== 'boolean') throw new Error(`${filename}: experimental.nextScriptWorkers must be a boolean.`);
-  config.experimental = { nextScriptWorkers, serverActions: validateServerActions(config.experimental.serverActions) };
+  config.experimental = { nextScriptWorkers, serverActions: validateServerActions(config.experimental.serverActions), optimizePackageImports: validateOptimizePackageImports(config.experimental.optimizePackageImports), proxyClientMaxBodySize: validateProxyBodySize(config.experimental.proxyClientMaxBodySize) };
   for (const key of ['basePath', 'assetPrefix']) {
     if (typeof config[key] !== 'string' || Buffer.byteLength(config[key]) > 4096) throw new Error(`${filename}: ${key} must be a string of at most 4096 bytes.`);
   }

package/build/font-cache.mjs

@@ -0,0 +1,50 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { mkdir, readFile, writeFile, rename, rm, readdir, lstat } from 'node:fs/promises';
+import path from 'node:path';
+
+const hash = value => createHash('sha256').update(value).digest('hex');
+const MAX_TOTAL = 64 * 1024 * 1024;
+let writes = Promise.resolve();
+
+/** Project-local build inputs, never responses/user data. Clearing this directory
+ * refreshes Google assets. A warm cache also permits an offline rebuild.
+ */
+export async function cachedFontResource(root, url, maximum, accept, download) {
+  if (!root) return download();
+  const directory = path.join(root, '.prnext-cache', 'fonts-v1');
+  const file = path.join(directory, hash(JSON.stringify([url, accept])) + '.bin');
+  try {
+    const metadata = await lstat(file);
+    if (metadata.isFile() && metadata.size > 65 && metadata.size <= maximum + 65) {
+      const stored = await readFile(file);
+      const bytes = stored.subarray(65);
+      if (stored[64] === 10 && hash(bytes) === stored.toString('ascii', 0, 64)) return bytes;
+    }
+  } catch (error) { if (!['ENOENT', 'ENOTDIR', 'EACCES'].includes(error.code)) throw error; }
+  const bytes = await download();
+  if (!bytes.length || bytes.length > maximum) throw new Error('Font resource exceeds its cache input limit');
+  const task = writes.catch(() => {}).then(async () => {
+    await mkdir(directory, { recursive: true });
+    const temporary = file + '.' + randomUUID() + '.tmp';
+    try {
+      await writeFile(temporary, Buffer.concat([Buffer.from(hash(bytes) + '\n'), bytes]), { flag: 'wx' });
+      await rename(temporary, file);
+    } finally { await rm(temporary, { force: true }); }
+    const entries = [];
+    for (const item of await readdir(directory, { withFileTypes: true })) {
+      if (!item.isFile() || !/^[a-f0-9]{64}\.bin$/.test(item.name)) continue;
+      try { entries.push({ file: path.join(directory, item.name), ...await lstat(path.join(directory, item.name)) }); }
+      catch (error) { if (error.code !== 'ENOENT') throw error; }
+    }
+    entries.sort((a, b) => b.mtimeMs - a.mtimeMs);
+    let total = 0;
+    for (let index = 0; index < entries.length; index++) {
+      total += entries[index].size;
+      if (index >= 256 || total > MAX_TOTAL) await rm(entries[index].file, { force: true });
+    }
+  });
+  writes = task;
+  try { await task; }
+  catch (error) { if (!['EACCES', 'EPERM', 'EROFS', 'ENOSPC', 'ENOENT'].includes(error.code)) throw error; }
+  return bytes;
+}

package/build/font-files.mjs

@@ -2,6 +2,7 @@ import { readFile, writeFile, mkdir, stat } from 'node:fs/promises';
 import path from 'node:path';
 import { createHash } from 'node:crypto';
 import googleFonts from './font-data.json' with { type: 'json' };
+import { cachedFontResource } from './font-cache.mjs';
 
 const formats = { woff: 'woff', woff2: 'woff2', ttf: 'truetype', otf: 'opentype', eot: 'embedded-opentype' };
 const types = { woff: 'font/woff', woff2: 'font/woff2', ttf: 'font/ttf', otf: 'font/otf', eot: 'application/vnd.ms-fontobject' };
@@ -36,7 +37,7 @@ function validate(kind, options) {
 }
 
 async function responseBytes(url, maximum, accept) {
-  const response = await fetch(url, { signal: AbortSignal.timeout(15_000), headers: { accept,
+  const response = await fetch(url, { signal: AbortSignal.timeout(15_000), redirect: 'error', headers: { accept,
     'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36' } });
   if (!response.ok) { await response.body?.cancel(); fail(`Unable to download ${url}: HTTP ${response.status}.`); }
   if (Number(response.headers.get('content-length')) > maximum) { await response.body?.cancel(); fail(`Font resource exceeds ${maximum} bytes.`); }
@@ -145,7 +146,8 @@ function googleOptions(name, options) {
 
 async function google(name, options, context) {
   const normalized = googleOptions(name, options);
-  const css = (await responseBytes(normalized.url, 1024 * 1024, 'text/css')).toString('utf8');
+  const resourceBytes = (url, maximum, accept) => cachedFontResource(context.projectRoot, url, maximum, accept, () => responseBytes(url, maximum, accept).catch(error => { throw new Error(`next/font: download failed for ${url}: ${error.message}. An initial build needs access to Google Fonts; subsequent builds can reuse .prnext-cache/fonts-v1.`, { cause: error }); }));
+  const css = (await resourceBytes(normalized.url, 1024 * 1024, 'text/css')).toString('utf8');
   const faces = [], downloaded = new Map();
   let total = 0;
   const facePattern = /(?:\/\*\s*([^*]+?)\s*\*\/\s*)?@font-face\s*\{([^}]+)\}/g;
@@ -161,7 +163,7 @@ async function google(name, options, context) {
       if (url.protocol !== 'https:' || url.hostname !== 'fonts.gstatic.com' || url.username || url.password) fail('Google font CSS referenced an unexpected font origin.');
       if (!downloaded.has(url.href)) {
         if (downloaded.size >= 64) fail('Google font call exceeds 64 files.');
-        const bytes = await responseBytes(url.href, MAX_FONT, 'font/woff2,font/woff,*/*');
+        const bytes = await resourceBytes(url.href, MAX_FONT, 'font/woff2,font/woff,*/*');
         total += bytes.length;
         if (total > 64 * 1024 * 1024) fail('Google font call exceeds 64 MiB.');
         const ext = path.extname(url.pathname).slice(1).toLowerCase();

package/build/fonts.mjs

@@ -37,7 +37,7 @@ export function createFonts({ projectRoot, stage, assetBase }) {
   async function prepare(kind, name, options, file, position) {
     const id = hash(JSON.stringify([path.relative(projectRoot, file), position, kind, name, options]));
     if (!compilations.has(id)) compilations.set(id, (async () => {
-      const compiled = await compileFont({ kind, name, options, file, id, stage, assetBase });
+      const compiled = await compileFont({ kind, name, options, file, id, stage, assetBase, projectRoot });
       const moduleFile = path.join(stage, '.entries', `font-${id}.mjs`);
       const cssFile = path.join(stage, '.entries', `font-${id}.css`);
       await mkdir(path.dirname(moduleFile), { recursive: true });

package/build/index.mjs

@@ -1,5 +1,6 @@
 import { rename } from '../runtime/fs.mjs';
 import { writeRuntimeContract } from './runtime-contract.mjs';
+import { bundleRuntime } from './bundle-runtime.mjs';
 import {frameworkImportName, frameworkRuntimeImportPattern} from './framework-imports.mjs';
 import { expandLocales, localizedStaticPaths } from './i18n.mjs';
 import { build as bundle, withCompilation, configureCompiler, compilerSource } from './compiler.mjs';
@@ -294,11 +295,15 @@ 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, moduleResolution: config.turbopack, cssModules, fonts, images, dev, defineEnvironment: environment, productionBrowserSourceMaps: config.productionBrowserSourceMaps, serverExternalPackages: config.serverExternalPackages });
     await checkTypeScript(project.root, config, { dev, tsconfig });
     fonts.attach(manifest);
     expandLocales(manifest);
+    // 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);
     await prerender(stage, manifest, dev);
     await prerenderApp(stage, manifest, dev);
     const pages = manifest.routes.filter(route => route.kind === 'page' && route.router !== 'app' && !route.internal);

package/build/metadata-conflicts.mjs

@@ -0,0 +1,13 @@
+import { readFile, stat } from 'node:fs/promises';
+import path from 'node:path';
+
+export async function validatePublicMetadata(root, pattern, file, dynamic) {
+  const publicFile = path.join(root, 'public', pattern.slice(1));
+  try {
+    const info = await stat(publicFile);
+    // Next production serves public files before App metadata handlers. An
+    // identical static duplicate is therefore unambiguous and safe to retain.
+    if (!dynamic && info.isFile() && info.size <= 16 * 1024 * 1024 && info.size === (await stat(file)).size && (await readFile(publicFile)).equals(await readFile(file))) return;
+    throw new Error(`Metadata route ${pattern} conflicts with a different file in public/. Keep a single source for this URL.`);
+  } catch (error) { if (error.code !== 'ENOENT' && error.code !== 'ENOTDIR') throw error; }
+}

package/build/metadata-images.mjs

@@ -1,4 +1,4 @@
-import { readFile, access } from 'node:fs/promises';
+import { readFile } from 'node:fs/promises';
 import path from 'node:path';
 import { createHash } from 'node:crypto';
 import { execFile } from 'node:child_process';
@@ -7,6 +7,7 @@ import { resolveNativeBinary } from '../native/resolve.mjs';
 import { validateAppConfig, mergeAppConfig } from './app-config.mjs';
 import { metadataExportNames } from './metadata-routes.mjs';
 import { pageExtensionPattern, validatePageSource } from './page-extensions.mjs';
+import { validatePublicMetadata } from './metadata-conflicts.mjs';
 const execute = promisify(execFile);
 const contentTypes = { ico: 'image/x-icon', png: 'image/png', jpg: 'image/jpeg', jpeg: 'image/jpeg', svg: 'image/svg+xml', gif: 'image/gif' };
 const imageTypes = { favicon: ['ico'], icon: ['ico', 'jpg', 'jpeg', 'png', 'svg'], 'apple-icon': ['jpg', 'jpeg', 'png'], 'opengraph-image': ['jpg', 'jpeg', 'png', 'gif'], 'twitter-image': ['jpg', 'jpeg', 'png', 'gif'] };
@@ -57,8 +58,7 @@ export async function scanMetadataImages({ root, appRoot, files, routes, pattern
     const pattern = validatePattern([...urlParts, filename, ...(multiple ? ['[__metadata_id__]'] : [])], relative);
     const signature = pattern.replace(/\[[^\]]+\]/g, '[]');
     if (patterns.has(signature)) throw new Error(`Conflicting metadata route ${relative} and ${patterns.get(signature)} at ${pattern}.`);
-    try { await access(path.join(root, 'public', pattern.slice(1))); throw new Error(`Metadata route ${pattern} conflicts with a file in public/.`); }
-    catch (error) { if (error.code !== 'ENOENT' && error.code !== 'ENOTDIR') throw error; }
+    await validatePublicMetadata(root, pattern, file, dynamic);
     patterns.set(signature, relative);
     const handlerConfig = dynamic ? await validateAppConfig(file) : {};
     handlerConfig.revalidate ??= false;

package/build/metadata-routes.mjs

@@ -1,10 +1,11 @@
-import { readFile, writeFile, access } from 'node:fs/promises';
+import { readFile, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 import { createHash } from 'node:crypto';
 import { parse } from '@babel/parser';
 import { validateAppConfig, mergeAppConfig } from './app-config.mjs';
 import { scanMetadataImages } from './metadata-images.mjs';
 import { pageExtensionPattern, validatePageSource } from './page-extensions.mjs';
+import { validatePublicMetadata } from './metadata-conflicts.mjs';
 
 const contentTypes = { robots: 'text/plain', sitemap: 'application/xml', manifest: 'application/manifest+json' };
 
@@ -31,8 +32,7 @@ export async function scanMetadataRoutes({ root, appRoot, files, routes, pattern
     const signature = pattern.replace(/\[[^\]]+\]/g, '[]');
     if (patterns.has(signature)) throw new Error(`Conflicting metadata route ${relative} and ${patterns.get(signature)} at ${pattern}.`);
     if (kind === 'manifest' && manifest) throw new Error('Multiple manifest metadata files found in the App Router root.');
-    try { await access(path.join(root, 'public', pattern.slice(1))); throw new Error(`Metadata route ${pattern} conflicts with a file in public/.`); }
-    catch (error) { if (error.code !== 'ENOENT' && error.code !== 'ENOTDIR') throw error; }
+    await validatePublicMetadata(root, pattern, file, dynamic);
     patterns.set(signature, relative);
     const handlerConfig = dynamic ? await validateAppConfig(file) : {};
     if (dynamic) {

package/build/native-packages.mjs

@@ -89,7 +89,11 @@ export function createNativePackages(projectRoot, { isClientSource }) {
             }
             if (args.path.startsWith('.') || args.path.startsWith('#')) return;
             const resolved = await esbuild.resolve(args.path, { importer: args.importer, resolveDir: args.resolveDir, kind: args.kind, pluginData: { prnextNativeResolving: true } });
-            if (resolved.errors.length || resolved.external || resolved.namespace !== 'file') return resolved;
+            // esbuild knows whether the original require() is inside try/catch.
+            // A plugin error would erase that optional-dependency semantics.
+            // Let normal resolution report genuine missing imports itself.
+            if (resolved.errors.length) return;
+            if (resolved.external || resolved.namespace !== 'file') return resolved;
             references.set(resolved.path, { specifier: args.path, importer: args.importer });
             const owner = ownerFor(resolved.path) || await discoverOwner(resolved.path, mode);
             if (owner) {

package/build/npm-packages.mjs

@@ -91,7 +91,8 @@ export function npmPackagesPlugin({ pages = false, projectRoot, transpilePackage
       // same validation as Pages to avoid bypassing compatibility transforms.
       if (!pages && !external.has(name)) return;
       const resolved = await resolve(args.path, args.importer || path.join(projectRoot, 'package.json'), args.kind);
-      if (resolved.errors.length || resolved.external || resolved.namespace !== 'file') return resolved;
+      if (resolved.errors.length) return;
+      if (resolved.external || resolved.namespace !== 'file') return resolved;
       // A tsconfig paths/baseUrl import can look like an npm specifier while
       // resolving to application source. Node cannot resolve that alias from
       // the emitted server bundle; keep the resolved source in the graph.

package/build/optimize-imports.mjs

@@ -0,0 +1,112 @@
+import { readFile, stat } from 'node:fs/promises';
+import path from 'node:path';
+import { parse } from '@babel/parser';
+import generateModule from '@babel/generator';
+import * as t from '@babel/types';
+import { generateMapped } from './source-maps.mjs';
+
+const generate = generateModule.default || generateModule;
+const name = node => node?.name ?? node?.value;
+
+export function validateOptimizePackageImports(value = []) {
+  if (!Array.isArray(value) || value.length > 256 || value.some(item => typeof item !== 'string' || !/^(?:@[a-zA-Z0-9_.-]+\/)?[a-zA-Z0-9_-][a-zA-Z0-9_.-]*$/.test(item))) {
+    throw new TypeError('experimental.optimizePackageImports must be an array of at most 256 npm package names');
+  }
+  return [...new Set(value)];
+}
+
+/** Only bypass pure ESM barrels in packages declaring sideEffects:false.
+ * Uncertain graphs retain their original import and normal bundler semantics.
+ * Never execute package code or infer private export paths from symbol names.
+ */
+export function createImportOptimizer(packages) {
+  const selected = new Set(packages), barrels = new Map(), dependencies = new Set();
+  async function inspect(file) {
+    if (!barrels.has(file)) barrels.set(file, (async () => {
+      if (!/\.[cm]?jsx?$/.test(file) || (await stat(file)).size > 2 * 1024 * 1024) return;
+      let directory = path.dirname(file), owner;
+      for (;;) {
+        try { owner = JSON.parse(await readFile(path.join(directory, 'package.json'), 'utf8')); break; }
+        catch (error) { if (error.code !== 'ENOENT') return; }
+        const parent = path.dirname(directory);
+        if (parent === directory) return;
+        directory = parent;
+      }
+      if (owner.sideEffects !== false || !selected.has(owner.name)) return;
+      dependencies.add(file);
+      dependencies.add(path.join(directory, 'package.json'));
+      const ast = parse(await readFile(file, 'utf8'), { sourceType: 'module', plugins: ['jsx'] });
+      // Crossing either directive here would change the RSC boundary identity.
+      if (ast.program.directives.some(d => d.value.value !== 'use strict')) return;
+      const imports = new Map(), exports = new Map();
+      for (const node of ast.program.body) {
+        if (t.isImportDeclaration(node)) {
+          if (!node.specifiers.length || node.attributes?.length) return;
+          for (const item of node.specifiers) {
+            if (t.isImportNamespaceSpecifier(item)) return;
+            imports.set(item.local.name, { source: node.source.value, imported: t.isImportDefaultSpecifier(item) ? 'default' : name(item.imported) });
+          }
+        } else if (!t.isExportNamedDeclaration(node) || node.declaration || node.attributes?.length) return;
+      }
+      for (const node of ast.program.body) if (t.isExportNamedDeclaration(node)) {
+        for (const item of node.specifiers) {
+          if (!t.isExportSpecifier(item)) return;
+          const target = node.source ? { source: node.source.value, imported: name(item.local) } : imports.get(name(item.local));
+          if (!target || !target.source.startsWith('./') && !target.source.startsWith('../')) return;
+          exports.set(name(item.exported), target);
+        }
+      }
+      return { exports, root: directory };
+    })());
+    return barrels.get(file);
+  }
+  async function optimize(source, file, resolve) {
+    if (![...selected].some(value => source.includes(value))) return source;
+    const ast = parse(source, { sourceType: 'unambiguous', sourceFilename: file, plugins: ['jsx', ...(/\.[cm]?tsx?$/.test(file) ? ['typescript'] : [])] });
+    let changed = false;
+    for (const node of ast.program.body) {
+      if (!t.isImportDeclaration(node) || !selected.has(node.source.value) || node.importKind === 'type' || !node.specifiers.length || node.attributes?.length) continue;
+      const resolved = await resolve(node.source.value, file);
+      if (!resolved) continue;
+      const barrel = await inspect(resolved);
+      if (!barrel) continue;
+      const replacements = [];
+      for (const item of node.specifiers) {
+        if (!t.isImportSpecifier(item) || item.importKind === 'type') continue;
+        const target = barrel.exports.get(name(item.imported));
+        if (!target) continue;
+        const leaf = await resolve(target.source, resolved);
+        if (!leaf) continue;
+        const relative = path.relative(barrel.root, leaf);
+        if (relative.startsWith('..') || path.isAbsolute(relative) || relative.split(path.sep).includes('node_modules')) continue;
+        replacements.push({ item, declaration: t.importDeclaration([target.imported === 'default' ? t.importDefaultSpecifier(item.local) : t.importSpecifier(item.local, t.isValidIdentifier(target.imported) ? t.identifier(target.imported) : t.stringLiteral(target.imported))], t.stringLiteral(leaf)) });
+      }
+      if (!replacements.length) continue;
+      const at = ast.program.body.indexOf(node);
+      node.specifiers = node.specifiers.filter(item => !replacements.some(value => value.item === item));
+      ast.program.body.splice(at, node.specifiers.length ? 0 : 1, ...replacements.map(value => value.declaration));
+      changed = true;
+    }
+    return changed ? generateMapped(generate, ast, { retainLines: true }, source, file) : source;
+  }
+  optimize.dependencies = dependencies;
+  return optimize;
+}
+
+export function optimizeImportsPlugins(plugins, packages) {
+  if (!packages?.length) return plugins;
+  const optimize = createImportOptimizer(packages);
+  return plugins.map(plugin => ({ ...plugin, setup(builder) {
+    return plugin.setup({ ...builder, onLoad(settings, callback) {
+      builder.onLoad(settings, async args => {
+        const result = await callback(args);
+        if (!result || typeof result.contents !== 'string' || args.namespace !== 'file' || !/\.[cm]?[jt]sx?$/.test(args.path) || result.errors?.length) return result;
+        const contents = await optimize(result.contents, args.path, async (specifier, importer) => {
+          const resolved = await builder.resolve(specifier, { importer, resolveDir: path.dirname(importer), kind: 'import-statement', pluginData: { prnextNpmResolving: true } });
+          return !resolved.errors.length && !resolved.external && resolved.namespace === 'file' && !resolved.suffix ? resolved.path : undefined;
+        });
+        return { ...result, contents, watchFiles: [...(result.watchFiles || []), ...optimize.dependencies] };
+      });
+    } });
+  } }));
+}

package/build/proxy-body-config.mjs

@@ -0,0 +1,10 @@
+export function validateProxyBodySize(value = 10 * 1024 * 1024) {
+  let bytes = value;
+  if (typeof value === 'string') {
+    const match = /^(\d+(?:\.\d+)?)\s*(b|kb|mb|gb)?$/i.exec(value.trim());
+    if (!match) throw new TypeError('experimental.proxyClientMaxBodySize expects bytes or a size such as "25mb"');
+    bytes = Math.floor(Number(match[1]) * 1024 ** Math.max(0, ['b', 'kb', 'mb', 'gb'].indexOf((match[2] || 'b').toLowerCase())));
+  }
+  if (!Number.isSafeInteger(bytes) || bytes < 1 || bytes > 32 * 1024 * 1024) throw new TypeError('experimental.proxyClientMaxBodySize must be between 1 byte and the PRNext 32 MiB buffered transport limit');
+  return bytes;
+}

package/build/scan.mjs

@@ -6,7 +6,7 @@ import { validateAppConfig, mergeAppConfig } from './app-config.mjs';
 import { scanMiddleware } from './middleware.mjs';
 import { scanMetadataRoutes } from './metadata-routes.mjs';
 import { scanAdvancedAppRoutes } from './app-routing.mjs';
-import { pageExtensionPattern, validatePageSource } from './page-extensions.mjs';
+import { pageExtensionPattern, validatePageSource, defaultPageExtensions } from './page-extensions.mjs';
 
 const sourceExtension = /\.(?:[cm]?js|jsx|tsx?)$/;
 
@@ -96,7 +96,7 @@ export async function scanProject(projectRoot, { basePath = '', pageExtensions,
     });
   }
   const appRoot = appRoots[0];
-  const { appNotFound, appGlobalError } = appRoot ? await scanAppRoutes({ root, appRoot, routes, patterns, sourceExtension }) : {};
+  const { appNotFound, appGlobalError } = appRoot ? await scanAppRoutes({ root, appRoot, routes, patterns, sourceExtension, pageExtensions }) : {};
   const metadataManifest = appRoot ? await scanMetadataRoutes({ root, appRoot, files: await walk(appRoot), routes, patterns, validatePattern, basePath, pageExtensions, appNotFound }) : undefined;
   if (metadataManifest) for (const route of routes) if (route.router === 'app' && route.kind === 'page') route.staticMetadata = { manifest: metadataManifest };
   if (!routes.length && !appNotFound) throw new Error('No page or API route found in the Pages Router or App Router directories.');
@@ -108,11 +108,13 @@ const appConventions = new Map([
   ['loading', 'loading'], ['error', 'error'], ['not-found', 'notFound'], ['default', 'default'],
 ]);
 
-async function scanAppRoutes({ root, appRoot, routes, patterns, sourceExtension }) {
+async function scanAppRoutes({ root, appRoot, routes, patterns, sourceExtension, pageExtensions = defaultPageExtensions }) {
   const directories = new Map();
   const configs = new Map();
   let appGlobalError;
-  for (const file of await walk(appRoot)) {
+  const rank = file => pageExtensions.findIndex(extension => file.endsWith('.' + extension));
+  const files = (await walk(appRoot)).sort((a, b) => rank(a) - rank(b) || a.localeCompare(b));
+  for (const file of files) {
     if (!sourceExtension.test(file) || file.endsWith('.d.ts')) continue;
     const relative = path.relative(appRoot, file).replaceAll(path.sep, '/');
     const parts = relative.split('/');
@@ -122,18 +124,18 @@ async function scanAppRoutes({ root, appRoot, routes, patterns, sourceExtension
       // This convention replaces the complete root document. A similarly named
       // file inside a route group or segment is not a nested error boundary.
       if (parts.length === 0) {
-        if (appGlobalError) throw new Error('Multiple global-error files in the App Router root. Keep only one.');
+        if (appGlobalError) { console.warn(`Duplicate global-error file ${relative}; using ${path.relative(appRoot, appGlobalError)} according to pageExtensions.`); continue; }
         appGlobalError = file;
       }
       continue;
     }
     if (!appConventions.has(filename)) continue;
     validatePageSource(file);
-    if (['page', 'layout', 'route'].includes(filename)) configs.set(file, await validateAppConfig(file));
     const directory = parts.join('/');
     const descriptor = directories.get(directory) || { directory, files: {} };
     const name = appConventions.get(filename);
-    if (descriptor.files[name]) throw new Error(`Multiple ${filename} files in App Router directory ${directory || '/'}. Keep only one file for each convention.`);
+    if (descriptor.files[name]) { console.warn(`Duplicate ${filename} file ${relative}; using ${path.relative(appRoot, descriptor.files[name])} according to pageExtensions.`); continue; }
+    if (['page', 'layout', 'route'].includes(filename)) configs.set(file, await validateAppConfig(file));
     descriptor.files[name] = file;
     directories.set(directory, descriptor);
   }

package/cli.mjs

@@ -5,6 +5,7 @@ import { readFile, writeFile, rm } from 'node:fs/promises';
 import { fileURLToPath } from 'node:url';
 import path from 'node:path';
 import { resolveNativeBinary, packageManifest } from './native/resolve.mjs';
+import { replaceWithNative } from './native/launch.mjs';
 import { readBuildDirectory } from './runtime/build-directory.mjs';
 import { shouldWatchProjectFile } from './runtime/env.mjs';
 
@@ -31,6 +32,11 @@ Use prnext for portable scripts; prn is a shortcut on compatible shells.
   prnext host [config] --check           Validate hosting configuration and builds
   prnext host [config] --status [--json]  Show memory, process and idle status
   prnext migrate [directory] [options]   Migrate a Next project's scripts and dependencies
+  prn login [--server URL]               Connect PRNext Cloud through your browser
+  prn deploy [directory]                 Upload sources, deploy and link the project
+  prn update [directory]                 Deploy changes to the linked Cloud project
+  prn whoami / prn logout                Show or disconnect your terminal account
+  prn deploy --help                     Cloud options and local development
 
 Migration options: --dry-run (preview), --no-install (prepare only), --json
   prnext migrate --check                Audit source compatibility without migrating
@@ -69,6 +75,11 @@ function stop(child) {
 async function main() {
   if (['help', '--help', '-h'].includes(command)) { console.log(help); return; }
   if (['--version', '-v'].includes(command)) { console.log(packageManifest.version); return; }
+  if (['login', 'logout', 'whoami', 'deploy', 'update'].includes(command)) {
+    const { cloudCommand } = await import('./runtime/cloud/client.mjs');
+    await cloudCommand(command, argv);
+    return;
+  }
   if (['pstart', 'prestart', 'pstop', 'pstatus', 'plist', 'plogs', 'pdelete', 'pstartup', 'pdown'].includes(command)) {
     const { persistentCommand } = await import('./runtime/persistent/client.mjs');
     await persistentCommand(command, argv);
@@ -184,6 +195,11 @@ async function main() {
   }
   const binary = await resolveNativeBinary();
   let outputDirectory = await readBuildDirectory(root);
+  const serverEnvironment = { ...process.env, NODE_ENV: process.env.NODE_ENV || (command === 'dev' ? 'development' : 'production') };
+  if (command === 'start' && serverEnvironment.NODE_ENV !== 'development') {
+    if (replaceWithNative(binary, ['start', root, '--worker', path.join(root, outputDirectory, 'runtime/worker.mjs'),
+      '--node', process.execPath, ...args], serverEnvironment)) return;
+  }
   const launch = () => spawn(binary, [command === 'routes' ? 'routes' : 'start', root,
     ...(command === 'routes' ? [] : ['--worker', path.join(root, outputDirectory, 'runtime/worker.mjs'), '--node', process.execPath,
       '--shutdown-on-stdin-eof']), ...args], { stdio: ['pipe', 'inherit', 'inherit'], windowsHide: true, env: { ...process.env, NODE_ENV: process.env.NODE_ENV || (command === 'dev' ? 'development' : 'production') } });

package/compat/after.cjs

@@ -0,0 +1,51 @@
+'use strict';
+const { AsyncLocalStorage } = require('node:async_hooks');
+
+function after(task) {
+  const context = require('./headers.cjs').currentRequest();
+  if (require('./data-cache.cjs').inCacheScope()) throw new Error('after() cannot be registered inside a cache scope');
+  if (!context.afterScope || !['route', 'action', 'after'].includes(context.phase)) throw new Error('after() currently requires a Node Route Handler or Server Action in PRNext. Server Component and Edge after() lifecycles are not implemented.');
+  context.afterScope.add(task, context, AsyncLocalStorage.snapshot());
+}
+
+function createAfterScope({ signal, timeoutMs = 25000, onTimeout = () => {}, onComplete, report = error => console.error('[prnext] after() failed:', error?.stack || error) } = {}) {
+  const queue = []; let count = 0, closed = false, finishing;
+  const deadline = Date.now() + timeoutMs;
+  const track = promise => signal?.[Symbol.for('prnext.request-work')]?.(promise, { timeoutMs: Math.max(1, deadline - Date.now()) });
+  const observe = promise => Promise.resolve(promise).then(value => ({ value }), error => ({ error }));
+  const scope = {
+    add(task, context, run) {
+      if (closed) throw new Error('after() request has already completed');
+      if (typeof task !== 'function' && (!task || typeof task.then !== 'function')) throw new TypeError('after() expects a callback or a Promise');
+      if (++count > 128) throw new Error('after() exceeds 128 tasks per request');
+      const pending = typeof task === 'function' ? null : observe(task);
+      if (pending) track(pending);
+      queue.push({ task: pending ? null : task, pending, context, run });
+    },
+    finish() {
+      return finishing ||= (async () => {
+        try {
+          while (queue.length) {
+            const item = queue.shift(), remaining = deadline - Date.now();
+            if (remaining <= 0) { const error = new Error('after() exceeded the request maxDuration'); report(error); onTimeout(error); break; }
+            const abort = new AbortController();
+            item.context.cookies._mutable = false;
+            item.context.phase = 'after';
+            item.context.signal = abort.signal;
+            item.context.cacheState.closed = false;
+            const work = item.pending || observe(Promise.resolve().then(() => item.run(item.task)));
+            track(work);
+            let timer;
+            try {
+              const outcome = await Promise.race([work, new Promise(resolve => { timer = setTimeout(() => { const error = new Error('after() exceeded the request maxDuration'); abort.abort(error); resolve({ error }); }, remaining); })]);
+              if ('error' in outcome) report(outcome.error);
+              if (abort.signal.aborted) { onTimeout(outcome.error); break; }
+            } finally { clearTimeout(timer); item.context.cacheState.closed = true; await onComplete?.(item.context); }
+          }
+        } finally { closed = true; queue.length = 0; }
+      })();
+    },
+  };
+  return scope;
+}
+module.exports = { after, createAfterScope };

package/compat/index.d.ts

@@ -118,6 +118,8 @@ export interface NextConfig {
   workerRetirement?: { idleSeconds?: number; laneIdleSeconds?: number; keepWarm?: boolean };
   /** Next dev page-retention hints; PRNext builds all routes without that eviction queue. */
   onDemandEntries?: { maxInactiveAge?: number; pagesBufferLength?: number };
+  /** Disable the Next development indicator. Error overlays and Fast Refresh remain enabled. */
+  devIndicators?: false;
   i18n?: { locales: string[]; defaultLocale: string; localeDetection?: boolean; domains?: Array<{domain: string; defaultLocale: string; locales?: string[]; http?: boolean}> };
   webpack?: (config: import('webpack').Configuration, context: { buildId: string; dev: boolean; isServer: boolean; nextRuntime?: 'nodejs' | 'edge'; webpack: typeof import('webpack'); defaultLoaders: {babel: {loader: string}} }) => import('webpack').Configuration | Promise<import('webpack').Configuration>;
   turbopack?: { root?: string; rules?: Record<string, TurbopackRule | TurbopackRule[]>; resolveAlias?: Record<string, string | { browser: string }>; resolveExtensions?: string[] };
@@ -141,7 +143,7 @@ export interface NextConfig {
     implementation?: 'sass' | 'sass-embedded';
     [option: string]: unknown;
   };
-  experimental?: { nextScriptWorkers?: boolean; serverActions?: true | { allowedOrigins?: string[]; bodySizeLimit?: number | string } };
+  experimental?: { nextScriptWorkers?: boolean; optimizePackageImports?: string[]; proxyClientMaxBodySize?: number | string; serverActions?: true | { allowedOrigins?: string[]; bodySizeLimit?: number | string } };
   trailingSlash?: boolean;
   skipTrailingSlashRedirect?: boolean;
   skipMiddlewareUrlNormalize?: boolean;

package/compat/server.cjs

@@ -1,5 +1,6 @@
 'use strict';
 const { NextRequest, NextResponse, NextURL } = require('./server-primitives.cjs');
+const { after } = require('./after.cjs');
 
 async function connection() {
   const context = require('./headers.cjs').currentRequest();
@@ -10,4 +11,4 @@ async function connection() {
   dynamicUsage('connection()', context);
 }
 
-module.exports = { NextRequest, NextResponse, NextURL, connection };
+module.exports = { NextRequest, NextResponse, NextURL, connection, after };

package/compat/server.d.cts

@@ -35,3 +35,5 @@ export interface MiddlewareConfig {
 export interface ProxyConfig { matcher?: MiddlewareConfig['matcher'] }
 /** Exclude the following render from prerendering until a request is available. */
 export function connection(): Promise<void>;
+/** Post-response work in Node Route Handlers. Other after() lifecycles fail explicitly. */
+export function after(task: Promise<unknown> | (() => unknown)): void;

package/native/launch.mjs

@@ -0,0 +1,19 @@
+// A production CLI has nothing to supervise once the native server starts.
+// On supported Linux Node releases, replace it instead of retaining a Node heap.
+// Keep the portable parent/pipe lifecycle for Windows, older Node, IPC callers
+// and instrumentation which may own descriptors or need JS exit handlers.
+export function replaceWithNative(binary, args, env, runtime = process) {
+  const options = [...(runtime.execArgv || []), env.NODE_OPTIONS || ''].join(' ');
+  // Only heap sizing is known not to require the Node launcher's lifetime.
+  // Be conservative for all other Node flags, including future diagnostics,
+  // loaders, preloads, permissions and signal-triggered reports/snapshots.
+  const customRuntime = options.replace(/(?:^|\s)--max[-_](?:semi|old)[-_]space[-_]size(?:=|\s+)\d+(?=\s|$)/g, '').trim();
+  if (runtime.platform !== 'linux' || typeof runtime.execve !== 'function'
+    || typeof runtime.send === 'function' || env.NODE_V8_COVERAGE || customRuntime) return false;
+  // execve keeps stdin/out/err and the PID. No parent pipe is needed: signals
+  // reach Rust directly, and its worker pipes still supervise every Node child.
+  // The marker also makes an old native binary fail clearly instead of using
+  // this lifecycle without the Linux parent-death guard it requires.
+  runtime.execve(binary, [binary, ...args, '--cli-exec'], env);
+  return true; // Only reached by injected test runtimes; real execve never returns.
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thomas.f/prnext",
-  "version": "0.1.12-alpha",
+  "version": "0.1.13-alpha",
   "license": "MIT",
   "description": "Experimental Rust-powered runtime for Next.js apps, React and npm",
   "homepage": "https://prnext.dev",
@@ -133,12 +133,12 @@
     "react-server-dom-webpack": "19.3.0"
   },
   "optionalDependencies": {
-    "prnext-darwin-arm64": "0.1.12-alpha",
-    "prnext-darwin-x64": "0.1.12-alpha",
-    "prnext-linux-arm64-gnu": "0.1.12-alpha",
-    "prnext-linux-x64-gnu": "0.1.12-alpha",
-    "@thomas.f/prnext-win32-x64-msvc": "0.1.12-alpha",
-    "@thomas.f/prnext-win32-arm64-msvc": "0.1.12-alpha"
+    "prnext-darwin-arm64": "0.1.13-alpha",
+    "prnext-darwin-x64": "0.1.13-alpha",
+    "prnext-linux-arm64-gnu": "0.1.13-alpha",
+    "prnext-linux-x64-gnu": "0.1.13-alpha",
+    "@thomas.f/prnext-win32-x64-msvc": "0.1.13-alpha",
+    "@thomas.f/prnext-win32-arm64-msvc": "0.1.13-alpha"
   },
   "engines": {
     "node": ">=22"