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

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

@@ -0,0 +1,16 @@
+import { createHash } from 'node:crypto';
+import { readFile, readdir, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+
+// Protocol compatibility does not imply safe retirement. These modules jointly
+// implement activity tracking, cancellation and post-response draining.
+export const lifecycleModules = ['worker.mjs', 'transport.mjs', 'request-work.mjs', 'app-render.mjs', 'app-stream-html.mjs', 'rsc-worker.mjs'];
+export async function writeRuntimeContract(stage) {
+  const files = (await Promise.all(['runtime', 'compat'].map(async directory =>
+    (await readdir(path.join(stage,directory))).filter(name => /\.(?:mjs|cjs|json)$/.test(name)).map(name => `${directory}/${name}`)))).flat().sort();
+  const modules = Object.fromEntries(await Promise.all(files.map(async name =>
+    [name, createHash('sha256').update(await readFile(path.join(stage, name))).digest('hex')])));
+  const contract = { schema: 1, protocol: 2, lifecycle: 1,
+    capabilities: ['activity', 'tracked-finalization', 'graceful-drain', 'lane-cancellation'], modules };
+  await writeFile(path.join(stage, 'runtime-contract.json'), JSON.stringify(contract, null, 2) + '\n');
+}

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/build/typescript-check.mjs

@@ -0,0 +1,20 @@
+import { createRequire } from 'node:module';
+
+const [, , compiler, filename] = process.argv;
+const ts = createRequire(import.meta.url)(compiler);
+const host = {
+  ...ts.sys,
+  onUnRecoverableConfigFileDiagnostic(diagnostic) {
+    process.stderr.write(ts.formatDiagnostics([diagnostic], formatHost));
+    process.exit(1);
+  },
+};
+const formatHost = { getCanonicalFileName: name => name, getCurrentDirectory: ts.sys.getCurrentDirectory, getNewLine: () => ts.sys.newLine };
+const parsed = ts.getParsedCommandLineOfConfigFile(filename, { noEmit: true }, host);
+const diagnostics = parsed.errors.length ? parsed.errors : ts.getPreEmitDiagnostics(ts.createProgram({
+  rootNames: parsed.fileNames, options: parsed.options, projectReferences: parsed.projectReferences,
+}));
+if (diagnostics.length) {
+  process.stderr.write(ts.formatDiagnostics(diagnostics, formatHost));
+  process.exitCode = 1;
+}

package/build/typescript.mjs

@@ -0,0 +1,49 @@
+import { stat } from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+
+const execute = promisify(execFile);
+
+export function validateTypeScript(input) {
+  if (input === undefined) return undefined;
+  if (!input || typeof input !== 'object' || Array.isArray(input)) throw new TypeError('typescript must be an object');
+  for (const key of Object.keys(input)) if (!['ignoreBuildErrors', 'tsconfigPath'].includes(key)) throw new TypeError(`typescript.${key} is not supported`);
+  const { ignoreBuildErrors = false, tsconfigPath = 'tsconfig.json' } = input;
+  if (typeof ignoreBuildErrors !== 'boolean') throw new TypeError('typescript.ignoreBuildErrors must be a boolean');
+  if (typeof tsconfigPath !== 'string' || !tsconfigPath || tsconfigPath.includes('\0') || Buffer.byteLength(tsconfigPath) > 4096) throw new TypeError('typescript.tsconfigPath must be a nonempty filesystem path of at most 4096 bytes');
+  return { ignoreBuildErrors, tsconfigPath };
+}
+
+export async function projectTsconfig(root, config) {
+  const name = config.typescript?.tsconfigPath ?? 'tsconfig.json';
+  const filename = path.resolve(root, name);
+  try {
+    if (!(await stat(filename)).isFile()) throw new Error(`TypeScript configuration is not a file: ${filename}`);
+    return filename;
+  } catch (error) {
+    if (error.code !== 'ENOENT') throw error;
+    if (name !== 'tsconfig.json') throw new Error(`typescript.tsconfigPath does not exist: ${filename}`, { cause: error });
+    return undefined;
+  }
+}
+
+/** Run the checker outside the build/dev process so its graph is released on exit.
+ * Never emit files, rewrite the user's config, or install packages implicitly. */
+export async function checkTypeScript(root, config, { dev = false, tsconfig } = {}) {
+  if (dev || !config.typescript || config.typescript.ignoreBuildErrors) return;
+  tsconfig ??= await projectTsconfig(root, config);
+  if (!tsconfig) throw new Error('TypeScript checking was explicitly enabled, but tsconfig.json does not exist. Create a TypeScript configuration, set typescript.tsconfigPath to an existing configuration, or explicitly set typescript.ignoreBuildErrors: true if types are checked separately.');
+  let compiler;
+  try { compiler = createRequire(path.join(root, 'package.json')).resolve('typescript'); }
+  catch (error) { throw new Error('TypeScript checking requires typescript in the project. Install it as a dev dependency, or explicitly set typescript.ignoreBuildErrors: true if a separate process checks types.', { cause: error }); }
+  try {
+    await execute(process.execPath, [fileURLToPath(new URL('./typescript-check.mjs', import.meta.url)), compiler, tsconfig], {
+      cwd: root, windowsHide: true, maxBuffer: 4 * 1024 * 1024,
+    });
+  } catch (error) {
+    throw new Error(`TypeScript check failed (${path.relative(root, tsconfig)}):\n${error.stdout || error.stderr || error.message}`, { cause: error });
+  }
+}

package/build/worker-retirement.mjs

@@ -0,0 +1,14 @@
+export function validateWorkerRetirement(value) {
+  if (value === undefined) return undefined;
+  if (!value || typeof value !== 'object' || Array.isArray(value)) throw new TypeError('workerRetirement must be an object');
+  for (const [key, setting] of Object.entries(value)) {
+    if (!['idleSeconds', 'laneIdleSeconds', 'keepWarm'].includes(key)) throw new TypeError(`workerRetirement.${key} is not supported`);
+    if (setting === undefined) continue;
+    if (key === 'keepWarm') {
+      if (typeof setting !== 'boolean') throw new TypeError('workerRetirement.keepWarm must be a boolean');
+    } else if (!Number.isSafeInteger(setting) || setting < 0 || setting > 604800) {
+      throw new TypeError(`workerRetirement.${key} must be an integer between 0 and 604800 seconds (0 disables retirement)`);
+    }
+  }
+  return Object.fromEntries(Object.entries(value).filter(([, v]) => v !== undefined));
+}

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
@@ -41,6 +47,7 @@ Simple next dev/build/start scripts become prnext commands; custom shell scripts
 
 Server options: --port 3000 --hostname 127.0.0.1 --workers 1 --inspect
 Production profiles: --profile balanced|speed|memory|classic
+Worker retirement: --worker-idle-seconds 300 --lane-idle-seconds 30 --keep-warm [true|false]
 Memory favors lower RAM under concurrency, accepting more waiting and CPU per response.
 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.
@@ -68,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);
@@ -183,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

@@ -112,14 +112,26 @@ export interface Rewrite extends CustomRoute { destination: string }
 export type ConfigRedirect = CustomRoute & Redirect;
 /** Implemented project options. Unsupported behavior-changing options fail the build. */
 export interface NextConfig {
+  /** PRNext only. CLI > environment > build configuration > profile.
+   * 0 disables the corresponding retirement; keepWarm retains one lane per used host.
+   */
+  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[] };
   images?: import('./image.cjs').ImageConfig;
   pageExtensions?: string[];
   reactStrictMode?: boolean;
+  /** Enabled React Compiler transforms are not implemented. */
+  reactCompiler?: false;
+  /** Typed route generation and validation are not implemented. */
+  typedRoutes?: false;
+  /** Production checks use the project's installed TypeScript without emitting files. */
+  typescript?: { ignoreBuildErrors?: boolean; tsconfigPath?: string };
   cacheComponents?: boolean;
   cacheLife?: Record<string, import('./cache.cjs').CacheLife>;
   transpilePackages?: string[];
@@ -131,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.11-alpha",
+  "version": "0.1.13-alpha",
   "license": "MIT",
   "description": "Experimental Rust-powered runtime for Next.js apps, React and npm",
   "homepage": "https://prnext.dev",
@@ -17,14 +17,30 @@
     "name": "Thomas",
     "url": "https://github.com/Lorkydey"
   },
-  "keywords": ["prnext", "nextjs", "react", "rust", "framework", "ssr", "server-components"],
+  "keywords": [
+    "prnext",
+    "nextjs",
+    "react",
+    "rust",
+    "framework",
+    "ssr",
+    "server-components"
+  ],
   "type": "module",
   "publishConfig": {
     "access": "public",
     "tag": "alpha",
     "registry": "https://registry.npmjs.org/"
   },
-  "files": ["cli.mjs", "index.mjs", "build/", "runtime/", "compat/", "native/", "release/"],
+  "files": [
+    "cli.mjs",
+    "index.mjs",
+    "build/",
+    "runtime/",
+    "compat/",
+    "native/",
+    "release/"
+  ],
   "scripts": {
     "prepublishOnly": "node release/verify.mjs"
   },
@@ -117,12 +133,12 @@
     "react-server-dom-webpack": "19.3.0"
   },
   "optionalDependencies": {
-    "prnext-darwin-arm64": "0.1.11-alpha",
-    "prnext-darwin-x64": "0.1.11-alpha",
-    "prnext-linux-arm64-gnu": "0.1.11-alpha",
-    "prnext-linux-x64-gnu": "0.1.11-alpha",
-    "@thomas.f/prnext-win32-arm64-msvc": "0.1.11-alpha",
-    "@thomas.f/prnext-win32-x64-msvc": "0.1.11-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"

package/release/verify.mjs

@@ -26,6 +26,15 @@ export async function verifyPackage() {
   if (source) {
     const cargo = await readFile(path.join(source, 'crates/prnext/Cargo.toml'), 'utf8');
     if (!cargo.includes(`version = "${pkg.version}"`)) throw new Error('Cargo and npm versions differ. Update crates/prnext/Cargo.toml and Cargo.lock before building release binaries.');
+    const top = JSON.parse(await readFile(path.join(source, 'package.json'), 'utf8'));
+    const lock = JSON.parse(await readFile(path.join(source, 'package-lock.json'), 'utf8'));
+    const cargoLock = (await readFile(path.join(source, 'Cargo.lock'), 'utf8')).replaceAll('\r\n', '\n');
+    if ([top.version, lock.version, lock.packages[''].version, lock.packages['packages/prnext'].version].some(version => version !== pkg.version) ||
+        !cargoLock.includes(`name = "prnext"\nversion = "${pkg.version}"`)) throw new Error('Workspace and lockfile versions differ; run scripts/release-version.mjs before building.');
+    for (const target of platforms) {
+      const native = lock.packages[`node_modules/${target.package}`];
+      if (native?.version !== pkg.version || native.optional !== true || lock.packages['packages/prnext'].optionalDependencies[target.package] !== pkg.version) throw new Error(`Missing or stale native lock entry: ${target.package}`);
+    }
   }
 }
 

package/runtime/api.mjs

@@ -178,6 +178,7 @@ function parseBody(bytes, contentType = '') {
 }
 
 export function runApi(options) {
+  if (options.timeoutMs === undefined && options.route?.cacheConfig?.maxDuration) options = { ...options, timeoutMs: options.route.cacheConfig.maxDuration * 1000 };
   return withCacheRequest(options, options.route?.router === 'app' ? 'route' : 'pages', context => runApiInner(options, context));
 }
 
@@ -189,11 +190,19 @@ async function runApiInner({ modulePath, route = {}, manifest = {}, production =
   const mod = (pages && loadedPagesModule(modulePath)) || await withSignal(loadModule(modulePath, pages), stream ? signal : undefined);
   const requestOriginal = originalUrl ? new URL(originalUrl, url) : undefined;
   if (requestOriginal) requestOriginal.pathname = removeBasePath(requestOriginal.pathname, manifest.config?.basePath || '');
-  const { request, bytes } = createRequest({ url, originalUrl: requestOriginal?.href, params, method, headers, body });
-  request.draftMode = cacheContext.draftMode;
-  request.previewData = cacheContext.previewData;
-  request.preview = cacheContext.previewData !== false;
-  if (typeof mod.default !== 'function') {
+  const appHandler = typeof mod.default !== 'function';
+  // App Route Handlers receive a NextRequest below. Constructing the Pages
+  // IncomingMessage here duplicates URL, header and cookie work and allocates
+  // an unused Duplex. Keep the existing Pages request path unchanged.
+  const { request, bytes } = appHandler
+    ? { bytes: Buffer.isBuffer(body) ? body : Buffer.from(body || '', 'base64') }
+    : createRequest({ url, originalUrl: requestOriginal?.href, params, method, headers, body });
+  if (!appHandler) {
+    request.draftMode = cacheContext.draftMode;
+    request.previewData = cacheContext.previewData;
+    request.preview = cacheContext.previewData !== false;
+  }
+  if (appHandler) {
     const {NextRequest, proxyRouteRequest} = await appRequestPrimitives();
     if (route.router === 'app' && manifest.dev) {
       const listing = await collectStaticParams({ page: mod, pageConfig: route.handlerConfig, segments: [] }, route.pattern);
@@ -221,6 +230,7 @@ async function runApiInner({ modulePath, route = {}, manifest = {}, production =
     const timeout = lifecycle && setTimeout(() => lifecycle.controller.abort(apiTimeoutError('response headers', timeoutMs)), timeoutMs);
     timeout?.unref();
     const pendingResponse = runRequestContext({ url, method, headers, params, production, cacheComponents: manifest.config?.cacheComponents, cacheLife: manifest.config?.cacheLife, cacheHandlers: manifest.config?.cacheHandlers, cacheHandler: manifest.config?.cacheHandler, cacheMaxMemorySize: manifest.config?.cacheMaxMemorySize, distDir: path.dirname(path.dirname(modulePath)), signal: lifecycle?.controller.signal || signal, previewModeId: manifest.previewModeId, basePath: manifest.config?.basePath || '', routePattern: route.pattern, cacheConfig: route.cacheConfig, phase: 'route', cacheState: cacheContext.cacheState, staticState: cacheContext.staticState, mutableCookies: true }, async () => {
+      currentRequest().afterScope = cacheContext.afterScope;
       let result;
       try { result = await handler(proxyRouteRequest(new NextRequest(requestOriginal || url, init), currentRequest()), { params: Promise.resolve(params) }); }
       catch (error) {