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

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/og.mjs

@@ -1,14 +1,8 @@
-import { cp, mkdir, readFile, writeFile } from 'node:fs/promises';
-import { createRequire } from 'node:module';
+import { cp, mkdir } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
 import path from 'node:path';
 export async function prepareImageResponse(stage) {
-  const directory = path.dirname(createRequire(import.meta.url).resolve('@vercel/og'));
   const target = path.join(stage, 'runtime/og');
   await mkdir(target, { recursive: true });
-  await writeFile(path.join(target, 'index.node.mjs'), `import {createRequire as __prnextRequire} from 'node:module';import {fileURLToPath as __prnextFile} from 'node:url';import {dirname as __prnextDir} from 'node:path';const require=__prnextRequire(import.meta.url),__filename=__prnextFile(import.meta.url),__dirname=__prnextDir(__filename);\n` + await readFile(path.join(directory, 'index.node.js'), 'utf8'));
-  for (const name of ['Geist-Regular.ttf', 'resvg.wasm']) await cp(path.join(directory, name), path.join(target, name));
-  await cp(path.join(directory, '../LICENSE'), path.join(target, 'LICENSE'));
-  await writeFile(path.join(target, 'NOTICE.txt'), 'Image renderer: @vercel/og 1.0.3 (https://github.com/vercel/og). PRNext adds Node CommonJS globals to its bundled ESM entry and includes the adjacent HarfBuzz WASM needed by that entry. Upstream bundled notices are preserved in index.node.mjs.\n');
-  const satori = createRequire(path.join(directory, 'index.node.js')).resolve('satori');
-  await cp(createRequire(satori).resolve('harfbuzzjs/hb.wasm'), path.join(target, 'hb.wasm'));
+  await cp(fileURLToPath(new URL('../runtime/og/', import.meta.url)), target, { recursive: true });
 }

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/output-contract.mjs

@@ -0,0 +1,41 @@
+import { open, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+
+export const OUTPUT_CONTRACT = 'build-output.json';
+const fields = ['version', 'adapter', 'buildId', 'manifest', 'assets', 'server', 'fallback'];
+
+/** The public adapter contract is separate from internal rendering metadata. */
+export function validateBuildOutput(value) {
+  const invalid = reason => { throw new Error(`Invalid PRNext build output: ${reason}`); };
+  if (!value || typeof value !== 'object' || Array.isArray(value)) invalid('expected an object');
+  if (value.version !== 1) invalid(`unsupported version ${value.version}; expected 1`);
+  if (Object.keys(value).some(key => !fields.includes(key)) || fields.some(key => !(key in value))) invalid('unexpected or missing fields');
+  if (!['react', 'static'].includes(value.adapter)) invalid('unsupported adapter');
+  if (typeof value.buildId !== 'string' || !/^[A-Za-z0-9_-]{1,128}$/.test(value.buildId)) invalid('invalid buildId');
+  if (value.manifest !== 'manifest.json') invalid('manifest must be manifest.json');
+  if (value.adapter === 'static') {
+    if (value.assets !== 'static' || value.server !== null || ![null, 'index.html'].includes(value.fallback)) invalid('invalid static entrypoints');
+  } else if (value.assets !== 'assets' || value.fallback !== null || !value.server ||
+    Object.keys(value.server).sort().join(',') !== 'entry,runtimeContract' ||
+    value.server.entry !== 'runtime/worker.mjs' || value.server.runtimeContract !== 'runtime-contract.json') invalid('invalid React entrypoints');
+  return value;
+}
+
+export async function writeBuildOutput(directory, manifest, { adapter = 'react', spa = false } = {}) {
+  const value = validateBuildOutput({ version: 1, adapter, buildId: manifest.buildId,
+    manifest: 'manifest.json', assets: adapter === 'static' ? 'static' : 'assets',
+    server: adapter === 'static' ? null : { entry: 'runtime/worker.mjs', runtimeContract: 'runtime-contract.json' },
+    fallback: spa ? 'index.html' : null });
+  await writeFile(path.join(directory, OUTPUT_CONTRACT), JSON.stringify(value, null, 2) + '\n');
+  return value;
+}
+
+export async function readBuildOutput(directory) {
+  const file = await open(path.join(directory, OUTPUT_CONTRACT), 'r');
+  try {
+    const bytes = Buffer.alloc(65537);
+    const { bytesRead } = await file.read(bytes, 0, bytes.length, 0);
+    if (bytesRead > 65536) throw new Error('Invalid PRNext build output: exceeds 64 KiB');
+    return validateBuildOutput(JSON.parse(bytes.subarray(0, bytesRead).toString('utf8')));
+  } finally { await file.close(); }
+}

package/build/precompress.mjs

@@ -49,6 +49,19 @@ async function compress(filename, cacheDirectory) {
   const original = await stat(filename);
   if (!original.size) return 'skipped';
   const sidecar = filename + '.gz';
+  // Static builders may already supply gzip files. Validate them rather than
+  // overwriting public input or publishing a mismatched encoded response.
+  const existing = await stat(sidecar).catch(error => { if (error.code !== 'ENOENT') throw error; });
+  if (existing) {
+    const input = createReadStream(sidecar), unzip = createGunzip();
+    const verified = digest(unzip, original.size);
+    const pumping = pipeline(input, unzip);
+    const [actual, expected] = await Promise.all([verified, digest(createReadStream(filename)), pumping]);
+    if (actual !== expected) throw new Error(`Precompressed asset does not match its source: ${path.basename(sidecar)}`);
+    await utimes(filename, original.atimeMs / 1000, original.mtimeMs / 1000);
+    await utimes(sidecar, original.atimeMs / 1000, original.mtimeMs / 1000);
+    return 'reused';
+  }
   const key = cacheDirectory && original.size <= 64*1024*1024 ? await digest(createReadStream(filename)) : null;
   const cached = key && path.join(cacheDirectory,key+'.gz');
   let reused = false;

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?)$/;
 
@@ -61,7 +61,7 @@ export async function scanProject(projectRoot, { basePath = '', pageExtensions,
   const appRoots = [];
   for (const name of ['app', 'src/app']) if (await exists(path.join(root, name))) appRoots.push(path.join(root, name));
   if (appRoots.length > 1) throw new Error('Both app/ and src/app/ exist. Keep exactly one App Router directory.');
-  if (!roots.length && !appRoots.length) throw new Error('No pages/, src/pages/, app/, or src/app/ directory found. Create app/page.tsx or pages/index.tsx to start.');
+  if (!roots.length && !appRoots.length) throw new Error('The React adapter needs a pages/, src/pages/, app/, or src/app/ directory. Create app/page.tsx or pages/index.tsx to start. For a Vite or other static site, run its own build, then prnext build --adapter static --from dist.');
   const pageRoot = roots[0];
   const files = (pageRoot ? await walk(pageRoot) : []).filter(file => sourceExtension.test(file) && !file.endsWith('.d.ts'));
   const routes = [];
@@ -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/build/static-adapter.mjs

@@ -0,0 +1,100 @@
+import { constants } from 'node:fs';
+import { copyFile, lstat, mkdir, readdir, realpath, rm, stat, writeFile } from 'node:fs/promises';
+import { randomUUID } from 'node:crypto';
+import path from 'node:path';
+import { rename } from '../runtime/fs.mjs';
+import { OUTPUT_POINTER, prepareBuildDirectory, readBuildDirectory, validateDistDir } from '../runtime/build-directory.mjs';
+import { writeBuildOutput } from './output-contract.mjs';
+import { precompressBuild } from './precompress.mjs';
+import { withBuildLock } from './build-lock.mjs';
+
+const MAX_FILES = 20000, MAX_BYTES = 512 * 1024 * 1024;
+const inside = (root, file) => file.startsWith(root + path.sep);
+const urlFor = file => '/' + file.split('/').map(encodeURIComponent).join('/');
+
+/** Import an already-built public directory. Never evaluate its config or code. */
+export async function buildStatic(directory, { from = 'dist', spa = false, distDir, dev = false } = {}) {
+  return withBuildLock(directory, root => importStatic(root, { from, spa, distDir, dev }));
+}
+
+async function importStatic(directory, { from, spa, distDir, dev }) {
+  if (dev) throw new Error('The static adapter imports production files; use the source framework for development.');
+  if (typeof spa !== 'boolean') throw new TypeError('spa must be a boolean');
+  const root = await realpath(directory);
+  // Reuse the output-directory restrictions to keep imports within this project
+  // and away from source/dependency/repository trees.
+  const relative = validateDistDir(from);
+  const output = distDir === undefined ? await readBuildDirectory(root) : validateDistDir(distDir);
+  const source = path.join(root, relative), destination = await prepareBuildDirectory(root, output);
+  if (source === destination || inside(source, destination) || inside(destination, source)) throw new Error('Static input and PRNext output directories must not overlap.');
+  let ancestor = root;
+  for (const part of relative.split('/')) {
+    ancestor = path.join(ancestor, part);
+    const entry = await lstat(ancestor);
+    if (entry.isSymbolicLink() || !entry.isDirectory()) throw new Error('Static input must use real directories, not symbolic links.');
+  }
+  if (!inside(root, await realpath(source))) throw new Error('Static input must stay inside the project.');
+  const index = await lstat(path.join(source, 'index.html')).catch(() => null);
+  if (!index?.isFile() || index.isSymbolicLink()) throw new Error('Static input needs index.html. Run your framework build first and select its public output with --from.');
+
+  const id = randomUUID(), stage = path.join(root, `.prnext-build-${id}`);
+  const backup = path.join(root, `.prnext-backup-${id}`), pointer = path.join(root, `.prnext-output-${id}.tmp`);
+  const manifest = { version: 1, buildId: id, config: { staticOnly: true, staticFallback: spa, compress: true, poweredByHeader: true }, routes: [], prerendered: [] };
+  const paths = new Set();
+  let count = 0, bytes = 0, previous = false, published = false;
+  const add = (url, file) => {
+    if (paths.has(url)) throw new Error(`Ambiguous static URL ${url}; remove the conflicting file or HTML alias.`);
+    paths.add(url);
+    manifest.prerendered.push({ path: url, file: `static/${file}`, revalidate: false });
+  };
+  async function copy(folder = '', depth = 0) {
+    if (depth > 64) throw new Error('Static input exceeds 64 directory levels.');
+    for (const name of (await readdir(path.join(source, folder))).sort()) {
+      if (name.includes('\\') || /[\x00-\x1f\x7f:]/.test(name) ||
+          name.startsWith('.') && !(folder === '' && name === '.well-known') ||
+          ['node_modules', '_prnext', '_next'].includes(name) || folder === '' && name === 'server') {
+        throw new Error(`Static input contains a private, reserved or server path: ${folder ? folder + '/' : ''}${name}. Select only browser-ready files.`);
+      }
+      const file = folder ? `${folder}/${name}` : name;
+      const entry = await lstat(path.join(source, file));
+      if (entry.isSymbolicLink()) throw new Error(`Static input cannot contain symbolic links: ${file}`);
+      if (entry.isDirectory()) { await copy(file, depth + 1); continue; }
+      if (!entry.isFile()) throw new Error(`Static input must contain regular files: ${file}`);
+      if (++count > MAX_FILES || (bytes += entry.size) > MAX_BYTES) throw new Error('Static input exceeds 20,000 files or 512 MiB.');
+      const target = path.join(stage, 'static', file);
+      await mkdir(path.dirname(target), { recursive: true });
+      await copyFile(path.join(source, file), target, constants.COPYFILE_EXCL);
+      const after = await lstat(path.join(source, file));
+      if (!after.isFile() || after.size !== entry.size || after.mtimeMs !== entry.mtimeMs || (await stat(target)).size !== entry.size) throw new Error(`Static input changed while being imported: ${file}. Retry after its build finishes.`);
+      add(urlFor(file), file);
+      if (file === 'index.html') add('/', file);
+      else if (file.endsWith('/index.html')) add(urlFor(file.slice(0, -11)), file);
+      else if (file.endsWith('.html')) add(urlFor(file.slice(0, -5)), file);
+    }
+  }
+  try {
+    await mkdir(stage);
+    await copy();
+    await writeFile(path.join(stage, 'manifest.json'), JSON.stringify(manifest, null, 2) + '\n');
+    await writeBuildOutput(stage, manifest, { adapter: 'static', spa });
+    await precompressBuild(stage, manifest, { cacheDirectory: path.join(root, '.prnext-cache/precompress-v1') });
+    // A failed import leaves the previously published build and pointer intact.
+    previous = await lstat(destination).then(() => true, error => { if (error.code === 'ENOENT') return false; throw error; });
+    await writeFile(pointer, JSON.stringify({ distDir: output }) + '\n', { flag: 'wx' });
+    if (previous) await rename(destination, backup);
+    try {
+      await rename(stage, destination);
+      published = true;
+      await rename(pointer, path.join(root, OUTPUT_POINTER));
+    } catch (error) {
+      if (published) await rename(destination, stage);
+      if (previous) await rename(backup, destination);
+      throw error;
+    }
+    if (previous) await rm(backup, { recursive: true, force: true });
+    return { ...manifest, outputDirectory: destination, files: count, bytes };
+  } finally {
+    await rm(pointer, { force: true });
+    await rm(stage, { recursive: true, force: true });
+  }
+}

package/cli.mjs

@@ -1,10 +1,11 @@
 #!/usr/bin/env node
 import { rename } from './runtime/fs.mjs';
 import { spawn } from 'node:child_process';
-import { readFile, writeFile, rm } from 'node:fs/promises';
+import { readFile, writeFile, rm, mkdir, readdir } 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';
 
@@ -15,6 +16,9 @@ const help = `PRNext ${packageManifest.version}
 Use prnext for portable scripts; prn is a shortcut on compatible shells.
 
   prnext build [directory]              Build React/TypeScript and static HTML
+  prnext build [directory] --adapter static [--from dist] [--spa]
+                                       Import an existing public build directory
+  prnext output [directory] [--json]    Read the versioned build output contract
   prnext start [directory] [options]    Start native Rust production server
   prnext pstart [directory] [options]   Start production persistently in the background
   prnext prestart [name]                Replace a persistent app after a health check
@@ -26,11 +30,16 @@ Use prnext for portable scripts; prn is a shortcut on compatible shells.
   prnext dev [directory] [options]      Rebuild and restart on source changes
   prnext routes [directory]             Display compiled routes
   prnext check [directory] [--json]      Check an existing Next project before building
-  prnext inspect [directory] [--json]    Explain routes, cache decisions and timings
+  prnext inspect [directory] [--json|--otlp] Explain routes, health and sampled timings
   prnext host [prnext.host.json]         Host built apps by hostname; wake on demand
   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
@@ -46,7 +55,7 @@ Memory favors lower RAM under concurrency, accepting more waiting and CPU per re
 Without an option: PRNEXT_PROFILE, legacy PRNEXT_MEMORY_PROFILE=compact, then balanced.
 Classic preserves the former standard settings; standard remains an alias. Legacy compact remains accepted.
 Development includes React Fast Refresh, stylesheet updates and an error overlay.
-Requires Node >=22. Published packages include the native server for supported platforms.
+Requires Node 22.23.4+, 24.22.1+ or 26.12.1+. Published packages include the native server for supported platforms.
 Rust is only needed when building the framework from source.
 `;
 
@@ -69,6 +78,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);
@@ -136,19 +150,36 @@ async function main() {
     if (!report.ok) process.exitCode = 1;
     return;
   }
-  if (!['build', 'start', 'dev', 'routes', 'check', 'inspect'].includes(command)) throw new Error(`Unknown command: ${command}\n${help}`);
+  if (!['build', 'start', 'dev', 'routes', 'check', 'inspect', 'output'].includes(command)) throw new Error(`Unknown command: ${command}\n${help}`);
   const args = [...argv];
   const root = path.resolve(args[0] && !args[0].startsWith('-') ? args.shift() : '.');
+  if (command === 'output') {
+    if (args.some(arg => arg !== '--json')) throw new Error('output accepts only [directory] and --json');
+    const { readBuildOutput } = await import('./build/output-contract.mjs');
+    const output = await readBuildOutput(path.join(root, await readBuildDirectory(root)));
+    if (args.includes('--json')) console.log(JSON.stringify(output, null, 2));
+    else console.log(`PRNext output v${output.version}: ${output.adapter}\nBuild: ${output.buildId}\nManifest: ${output.manifest}\nAssets: ${output.assets}\nServer: ${output.server?.entry || 'none'}\nSPA fallback: ${output.fallback || 'disabled'}`);
+    return;
+  }
   if (command === 'inspect') {
-    if (args.some(arg => arg !== '--json')) throw new Error('inspect accepts only [directory] and --json');
-    const { inspectProject, printInspection } = await import('./build/inspect.mjs');
+    if (args.some(arg => !['--json', '--otlp'].includes(arg)) || args.includes('--json') && args.includes('--otlp')) throw new Error('inspect accepts [directory] and either --json or --otlp');
+    const { inspectProject, printInspection, inspectionMetrics } = await import('./build/inspect.mjs');
     const report = await inspectProject(root);
-    if (args.includes('--json')) console.log(JSON.stringify(report, null, 2)); else printInspection(report);
+    if (args.includes('--otlp')) console.log(JSON.stringify(inspectionMetrics(report), null, 2));
+    else if (args.includes('--json')) console.log(JSON.stringify(report, null, 2)); else printInspection(report);
     return;
   }
   if (['start', 'dev'].includes(command) && args.includes('--inspect')) {
     args.splice(args.indexOf('--inspect'), 1);
     process.env.PRNEXT_INSPECT_DIR = path.join(root, '.prnext-cache/inspect');
+    await mkdir(process.env.PRNEXT_INSPECT_DIR, {recursive:true, mode:0o700});
+    process.env.PRNEXT_METRICS_FILE ||= path.join(process.env.PRNEXT_INSPECT_DIR, `metrics-${process.pid}.jsonl`);
+    const old = (await readdir(process.env.PRNEXT_INSPECT_DIR)).filter(name => /^metrics-\d+\.jsonl$/.test(name));
+    for (const name of old.slice(0, Math.max(0, old.length - 4))) {
+      const pid = Number(name.slice(8,-6));
+      try { process.kill(pid, 0); }
+      catch (error) { if (error.code === 'ESRCH') await rm(path.join(process.env.PRNEXT_INSPECT_DIR,name),{force:true}); }
+    }
   }
   if (command === 'build' || command === 'dev') {
     // Build plugins such as Contentlayer read cwd/INIT_CWD rather than webpack's
@@ -172,18 +203,40 @@ async function main() {
     return;
   }
   if (command === 'build') {
-    const dev = args.includes('--dev');
-    if (args.some(arg => arg !== '--dev')) throw new Error('build accepts only [directory] and --dev');
+    const options = {};
+    for (let i = 0; i < args.length; i++) {
+      const flag = args[i];
+      if (flag === '--dev') options.dev = true;
+      else if (flag === '--spa') options.spa = true;
+      else if (flag === '--adapter' || flag === '--from') {
+        const value = args[++i];
+        if (!value || value.startsWith('-')) throw new Error(`${flag} requires a value`);
+        const key = flag.slice(2);
+        if (options[key] !== undefined) throw new Error(`Duplicate build option: ${flag}`);
+        options[key] = value;
+      } else throw new Error(`Unknown build option: ${flag}`);
+    }
+    const dev = !!options.dev;
     const envMode = process.env.NODE_ENV === 'test' ? 'test' : undefined;
     process.env.NODE_ENV = dev ? 'development' : 'production';
-    const { build } = await import('./build/index.mjs');
     const started = performance.now();
-    await build(root, { dev, envMode });
+    if (options.adapter === 'static') {
+      const { buildStatic } = await import('./build/static-adapter.mjs');
+      await buildStatic(root, options);
+    } else {
+      const { build } = await import('./build/index.mjs');
+      await build(root, { ...options, dev, envMode });
+    }
     console.log(`PRNext built ${root} in ${((performance.now() - started) / 1000).toFixed(2)}s`);
     return;
   }
   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/diagnostics.cjs

@@ -4,6 +4,10 @@ const directory = process.env.PRNEXT_INSPECT_DIR;
 const { threadId } = require('node:worker_threads');
 let queue = [], scheduled = false, writing = false, size;
 const limit = 1024 * 1024;
+if (directory) setInterval(() => {
+  const {rss, heapUsed} = process.memoryUsage();
+  record('process', {rssBytes:rss, heapUsedBytes:heapUsed});
+}, 5000).unref();
 function record(type, fields = {}) {
   if (!directory || queue.length >= 256) return;
   const line = JSON.stringify({ time: Date.now(), pid: process.pid, type, ...fields }) + '\n';