@thomas.f/prnext 0.1.0-alpha.1 → 0.1.11-alpha

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Thomas (Lorkydey)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -2,53 +2,190 @@
 
 # PRNext
 
-[Website](https://prnext.dev) · [GitHub](https://github.com/Lorkydey/PRNext) · [Report an issue](https://github.com/Lorkydey/PRNext/issues)
+[Website](https://prnext.dev) · [npm](https://www.npmjs.com/package/@thomas.f/prnext) · [GitHub](https://github.com/Lorkydey/PRNext) · [Report an issue](https://github.com/Lorkydey/PRNext/issues)
 
 A Rust-powered runtime for Next.js projects, with React and npm modules running on Node.js.
 
-> **Very early alpha — 0.1.0-alpha.1**
->
-> Built for experimentation and feedback, not production applications. Next.js compatibility is partial. Expect bugs, missing features and breaking changes.
+> **Very early alpha.** Built for experimentation and feedback. Next.js compatibility is partial; expect bugs, missing features and breaking changes.
 
-## Install and migrate
+## Latest update
 
-Node.js 22+ is required. This alpha uses matching React, React DOM and React Server Components versions:
+<details>
+<summary><strong>0.1.1-alpha · October 8, 2026 · Features & fixes</strong></summary>
+
+**README update:** `0.1.11-alpha` updates the README only; runtime features and fixes remain those of `0.1.1-alpha`.
+
+### Added
+
+- **Windows x64 & ARM64:** native packages alongside macOS and Linux glibc support.
+- **Persistent apps:** background processes, crash recovery, rotating logs, health-checked replacements and optional restoration at login.
+- **Multi-app hosting:** hostname routing, on-demand startup, idle sleep and sampled memory budgets.
+- **Migration checks:** source audits and optional GET response comparisons with `migrate --check`.
+- **Inspector:** opt-in route, cache and request timing diagnostics.
+
+### Fixed
+
+- Standalone dependency tracing for Windows drives, scoped packages and workspace aliases.
+- Development process shutdown and file replacement on Windows.
+- Cold-worker connection bursts on macOS.
+- Windows package publishing and portable `prnext` migration scripts.
+
+</details>
+
+[Full changelog](https://github.com/Lorkydey/PRNext/blob/main/CHANGELOG.md)
+
+## Install & upgrade
+
+Node.js **22+** · Windows, macOS and Linux glibc · x64 and ARM64
+
+<details>
+<summary><strong>Install · migrate an existing Next.js app</strong></summary>
+
+Run these commands from your application directory. The current alpha requires matching React, React DOM and React Server Components versions:
+
+```sh
+npm install @thomas.f/prnext@alpha react@19.3.0 react-dom@19.3.0 react-server-dom-webpack@19.3.0
+npx --no-install prnext migrate --dry-run
+npx --no-install prnext migrate
+npx --no-install prnext check
+npx --no-install prnext dev
+```
+
+Review the dry run before applying migration. Migration backs up your package files and keeps Next.js and your application source. Compatibility checks help find issues; they do not guarantee that every Next.js feature works.
+
+Install only `@thomas.f/prnext`. Keep optional dependencies enabled: npm installs the matching native component automatically. Rust is not required to use a published release.
+
+</details>
+
+<details>
+<summary><strong>Upgrade · update an existing PRNext project</strong></summary>
+
+Stop your development or production process before changing dependencies. If you use `pstart`, follow the [persistent app upgrade guide](https://github.com/Lorkydey/PRNext#upgrade-persistent-apps) first.
 
 ```sh
 npm install @thomas.f/prnext@alpha react@19.3.0 react-dom@19.3.0 react-server-dom-webpack@19.3.0
-npx --no-install prn migrate --dry-run
-npx --no-install prn migrate
-npx --no-install prn check
-npx --no-install prn dev
+npx --no-install prnext --version
+npx --no-install prnext check
+npx --no-install prnext build
 ```
 
-The package provides both `prnext` and its shortcut `prn`. Migration backs up your package files and keeps Next.js and your application source. The preflight check does not guarantee full compatibility with your application.
+Then restart your app with its usual command; for a foreground production server:
+
+```sh
+npx --no-install prnext start
+```
+
+This updates the existing `@thomas.f/prnext` dependency and its native component together. You do not need to migrate an already-migrated project again. Commit the updated package manifest and lockfile.
+
+Use `@alpha` to select the current alpha release. `latest` is a separate npm tag; a dependency already installed in a project does not change until you update it.
+
+</details>
+
+<details>
+<summary><strong>Build & run · development and production</strong></summary>
+
+For development:
+
+```sh
+npx --no-install prnext dev
+```
 
-## Build and run
+For production:
 
 ```sh
-npx --no-install prn build
-npx --no-install prn start
+npx --no-install prnext build
+npx --no-install prnext start
 ```
 
-Balanced is the default production profile. Choose a profile with:
+The portable command is `prnext`. The shortcut `prn` is available in compatible shells. On Windows 10 and Windows Server 2022, use `prnext`: [Windows reserves the name PRN](https://learn.microsoft.com/en-us/windows/win32/fileio/naming-a-file).
+
+</details>
+
+<details>
+<summary><strong>Runtime profiles · balanced, speed, memory and classic</strong></summary>
+
+Balanced is the default. Set a profile when starting the production server:
+
+| Profile | Command | Priority |
+| --- | --- | --- |
+| Balanced | `npx --no-install prnext start --profile balanced` | Memory, CPU and response times |
+| Speed | `npx --no-install prnext start --profile speed` | Throughput and responsiveness |
+| Memory | `npx --no-install prnext start --profile memory` | Lower memory usage |
+| Classic | `npx --no-install prnext start --profile classic` | Original runtime settings |
+
+Results depend on your workload; see the [benchmark and its methodology](https://github.com/Lorkydey/PRNext#early-benchmarks-against-nextjs).
+
+</details>
+
+## Guides
+
+<details>
+<summary><strong>Migration audit, inspector and multi-app hosting</strong></summary>
+
+### Migration audit, inspector and multi-app hosting
 
 ```sh
-npx --no-install prn start --profile balanced
-npx --no-install prn start --profile speed
-npx --no-install prn start --profile memory
-npx --no-install prn start --profile classic
+prnext migrate ./my-app --check --json
+prnext migrate ./my-app --check --against http://localhost:3000 --candidate http://localhost:3001 --routes paths.json
+prnext start ./my-app --inspect
+prnext inspect ./my-app --json
+prnext host prnext.host.json --check
+prnext host prnext.host.json
+prnext host prnext.host.json --status --json
 ```
 
-## Platforms
+The migration audit reports file/line diagnostics without rewriting the application. Response comparison checks GET status, redirects and normalized bodies between servers you start separately. HTML comparison excludes scripts/styles and does not replace browser tests.
+
+The inspector explains build decisions and summarizes optional local HTTP, fetch, cache and invalidation samples. Durations end at response headers. Runtime logs omit request bodies, credentials and query strings, and hash tag/path identifiers. Measurements are bounded and may drop samples under load.
+
+The host uses separate native server/Node process trees, starts apps on demand and stops idle apps. A minimal configuration is `{"memoryMb":512,"apps":[{"name":"site","root":"./site","hosts":["site.localhost"],"memoryMb":256,"idleSeconds":300}]}`. Roots are relative to this file; apps must already have production builds. Additional app options are `workers`, `profile`, `env` and `inspect`. The listener defaults to `127.0.0.1:8080`; set `hostname` and `port` explicitly when needed.
+
+Memory budgets reserve capacity and monitor process-tree RSS about once per second. An excess stops the app and imposes a 30-second cooldown; this is not a kernel hard limit. Leave memory for the gateway, OS and overshoot. Sleeping loses in-process state and background work. Apps run as the same OS user, so this mode is for trusted applications. HTTP streaming is supported; WebSocket upgrades are not. Configure public DNS/TLS and OS services separately.
+
+See the [repository guide and example configuration](https://github.com/Lorkydey/PRNext#host-several-applications) for the full workflow.
+
+</details>
 
-Prebuilt packages support macOS arm64/x64 and Linux glibc arm64/x64. Use WSL on Windows. Alpine/musl and native Windows do not yet have prebuilt packages. Linux binaries are built on Ubuntu 22.04 with glibc 2.35.
+<details>
+<summary><strong>Persistent production commands</strong></summary>
+
+### Persistent production commands
+
+`prnext start` remains a foreground command. Use `prnext pstart --name web --port 3000` to keep a built app running after the terminal closes. `prnext pstatus` (or `plist`) lists apps, `prnext plogs web --follow` tails logs, `prnext prestart web` loads the current build through a health check, and `prnext pstop web` stops it. `pdelete` removes saved settings; `pdown` stops the supervisor while preserving enabled apps for restoration. Lifecycle commands accept `--all` where shown by `prnext pstart --help`.
+
+Apps restart after crashes with increasing delays and a retry limit. A separate watchdog supervises the manager. Replacements get a private build copy and must return HTTP 2xx/3xx from `--health-path /` within `--health-timeout 15000` ms before traffic switches; a failed candidate leaves the old instance serving. Existing requests can finish for `--drain-timeout 30000` ms. Dependencies, public files and disk caches remain shared. This adds a Node HTTP proxy; WebSocket upgrades are not supported and crashes can interrupt requests.
+
+Settings, control credentials and logs live in `~/.prnext/processes` (`PRNEXT_PM_HOME` overrides it). Logs rotate at 10 MiB plus three older segments. Apps load project `.env` files; caller-shell secrets are not saved. `prnext pstartup` opts into restoration on the next user login through Windows Task Scheduler, a macOS LaunchAgent or a Linux systemd user service; `--remove` removes that startup configuration. Windows/macOS startup is per-user, not a pre-login system service. Linux boot-time operation requires administrator-configured user lingering. Re-run `pstartup` after moving or upgrading Node or PRNext. See the [persistent command guide](https://github.com/Lorkydey/PRNext#keep-production-apps-running).
+
+Before upgrading a supervised application, follow the [persistent app upgrade guide](https://github.com/Lorkydey/PRNext#upgrade-persistent-apps).
+
+</details>
+
+<details>
+<summary><strong>Platforms</strong></summary>
+
+### Platforms
+
+Native package targets cover Windows MSVC arm64/x64, macOS arm64/x64 and Linux glibc arm64/x64. Windows runs directly from PowerShell or Command Prompt, without WSL. Alpine/musl is not a prebuilt target. Linux binaries are built on Ubuntu 22.04 with glibc 2.35. Framework and native components use matching release versions.
 
 Keep npm optional dependencies enabled: PRNext automatically installs the binary for your platform. Rust is not required to use the published package.
 
+</details>
+
 ## Links and feedback
 
 - Website and benchmarks: [prnext.dev](https://prnext.dev)
 - Source and contributions: [Lorkydey/PRNext](https://github.com/Lorkydey/PRNext)
 - Bug reports: [GitHub Issues](https://github.com/Lorkydey/PRNext/issues)
 - Questions and suggestions: [contact@heythomas.dev](mailto:contact@heythomas.dev)
+
+<details>
+<summary><strong>License & credits</strong></summary>
+
+### License and credits
+
+PRNext is licensed under the [MIT License](LICENSE), copyright © 2026 Thomas (Lorkydey). Commercial use, modification, and redistribution are permitted; keep the copyright and license notice when distributing copies or substantial portions of the software. Third-party components retain their own licenses.
+
+If PRNext helps your project, a credit such as **“PRNext by Thomas (Lorkydey)”** with a link to [prnext.dev](https://prnext.dev) would be appreciated. A public credit is optional, not an additional license condition.
+
+</details>

package/build/app-static.mjs

@@ -86,6 +86,7 @@ export async function prerenderApp(stage, manifest, dev) {
         // continuation itself is never patched.
         const rendered = await pages.prerenderAppRoute({ ...options, path: fallback.path, params, partialParams: unknown });
         if (rendered.partial) {
+          route.dynamicReasons = [...new Set([...(route.dynamicReasons || []), ...(rendered.metadata?.dynamicReasons || [])])];
           const file = `static/generic-${createHash('sha256').update(route.id + JSON.stringify(supplied)).digest('hex').slice(0, 20)}.json`;
           await writeFile(path.join(stage, file), JSON.stringify({ ...rendered.partial, ...rendered.metadata }));
           (route.pprGeneric ||= []).push({ file, params: supplied, unknown });
@@ -119,6 +120,7 @@ export async function prerenderApp(stage, manifest, dev) {
           continue;
         }
         if (rendered.dynamic) {
+          route.dynamicReasons = [...new Set([...(route.dynamicReasons || []), rendered.reason || 'request-time data'])];
           if (!handler && config.dynamic === 'error') throw new Error(`App route ${entry.path} with dynamic='error' used dynamic data: ${rendered.reason || 'dynamic rendering required'}.`);
           if (!dynamic) { delete route.ssg; delete route.fallback; delete route.pprFallback; }
           else {

package/build/compiler.mjs

@@ -4,6 +4,7 @@ import { runLoaders } from 'loader-runner';
 import fs from 'node:fs';
 import { mkdir, writeFile, readFile } from 'node:fs/promises';
 import path from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { createRequire } from 'node:module';
 import { moduleResolutionPlugin, validateWebpackResolution } from './module-resolution.mjs';
 import { cachedLoader } from './loader-cache.mjs';
@@ -61,7 +62,7 @@ async function targetConfig(state, target) {
     const webpack = state.config.webpack ? (await import('webpack')).default : undefined;
     const base = { mode:state.dev?'development':'production', context:state.root, resolve:{alias:{},extensions:['.tsx','.ts','.jsx','.js','.mjs','.json']},module:{rules:[]},plugins:[] };
     const configured = state.config.webpack ? await state.config.webpack(base,{buildId:state.buildId,dev:state.dev,isServer:target!=='browser',nextRuntime:target==='browser'?undefined:target==='edge'?'edge':'nodejs',webpack,
-      defaultLoaders:{babel:{loader:new URL('./passthrough-loader.cjs',import.meta.url).pathname}}}) : base;
+      defaultLoaders:{babel:{loader:fileURLToPath(new URL('./passthrough-loader.cjs',import.meta.url))}}}) : base;
     if (!configured || typeof configured !== 'object') throw new Error('webpack hook must return its configuration');
     for (const key of Object.keys(configured)) if (!['mode','context','resolve','module','plugins','watchOptions'].includes(key)) throw new Error(`webpack.${key} cannot be translated to the PRNext compiler`);
     const watchOptions = configured.watchOptions;

package/build/dev.mjs

@@ -50,6 +50,7 @@ export function createRefreshTransform(projectRoot) {
   projectRoot = path.resolve(projectRoot);
   const canonicalRoot = realpath(projectRoot).catch(() => projectRoot);
   return async (source, filename) => {
+    filename = path.resolve(filename);
     if (filename.includes(`${path.sep}node_modules${path.sep}`) || filename.includes(`${path.sep}.prnext-build-`)) return source;
     // Bundlers resolve symlinks (including /var -> /private/var on macOS).
     // Compare against both spellings so temporary/linked apps still refresh.

package/build/index.mjs

@@ -1,7 +1,8 @@
+import { rename } from '../runtime/fs.mjs';
 import {frameworkImportName, frameworkRuntimeImportPattern} from './framework-imports.mjs';
 import { expandLocales, localizedStaticPaths } from './i18n.mjs';
 import { build as bundle, withCompilation, configureCompiler, compilerSource } from './compiler.mjs';
-import { mkdir, readFile, writeFile, rename, rm, cp, stat, readdir } from 'node:fs/promises';
+import { mkdir, readFile, writeFile, rm, cp, stat, readdir } from 'node:fs/promises';
 import path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { createRequire } from 'node:module';

package/build/inspect.mjs

@@ -0,0 +1,68 @@
+import { readFile, readdir, stat } from 'node:fs/promises';
+import path from 'node:path';
+import { readBuildDirectory } from '../runtime/build-directory.mjs';
+
+export function explainRoute(route, manifest) {
+  const seeds = manifest.prerendered.filter(seed => seed.routeId === route.id || (!seed.routeId && seed.path === route.pattern));
+  const config = route.cacheConfig || {};
+  const reasons = [...(route.dynamicReasons || [])];
+  if (route.ssp) reasons.push('getServerSideProps runs for each request');
+  if (route.gip) reasons.push('page getInitialProps runs for each request');
+  if (route.appGip && !route.ssg) reasons.push('custom App getInitialProps disables automatic static rendering');
+  if (config.dynamic === 'force-dynamic') reasons.push('dynamic is force-dynamic');
+  if (config.revalidate === 0) reasons.push('revalidate is 0');
+  if (config.forceNoStore || config.fetchCache === 'force-no-store') reasons.push('route data cache is disabled');
+  if (config.runtime === 'edge') reasons.push('Edge runtime');
+  if (!reasons.length && !seeds.length && !route.ssg) reasons.push(route.kind === 'api' ? 'request handler' : route.router === 'app' ? 'request-time rendering or paths not generated at build time' : 'getServerSideProps, getInitialProps, or another request-time dependency');
+  const partial = Boolean(route.ppr || route.pprGeneric || route.fallback === 'ppr');
+  const mode = partial ? 'partial' : seeds.length || route.ssg ? 'static / ISR' : 'dynamic';
+  return { pattern: route.pattern, router: route.router || 'pages', kind: route.kind, mode,
+    reasons: [...new Set(reasons)], prerenderedPaths: seeds.length,
+    revalidate: [...new Set(seeds.map(seed => seed.revalidate ?? false))],
+    invalidation: { tags: [...new Set(seeds.flatMap(seed => seed.tags || []))], paths: [...new Set(seeds.flatMap(seed => seed.paths || []))] } };
+}
+export async function inspectProject(directory) {
+  const root = path.resolve(directory), output = await readBuildDirectory(root);
+  let manifest;
+  try { manifest = JSON.parse(await readFile(path.join(root, output, 'manifest.json'), 'utf8')); }
+  catch (error) { throw new Error(`Cannot read a build in ${root}. Run prn build first.`, { cause: error }); }
+  const folder = path.join(root, '.prnext-cache/inspect');
+  let names = [];
+  try { names = (await readdir(folder)).filter(name => /^(?:worker-\d+-\d+|native-\d+)\.jsonl(?:\.1)?$/.test(name)); }
+  catch (error) { if (error.code !== 'ENOENT') throw error; }
+  const files = await Promise.all(names.map(async name => ({ name, info: await stat(path.join(folder, name)).catch(() => null) })));
+  const events = [];
+  for (const { name, info } of files.filter(value => value.info?.isFile() && value.info.size <= 2 * 1024 ** 2).sort((a, b) => b.info.mtimeMs - a.info.mtimeMs).slice(0, 64)) {
+    const source = await readFile(path.join(folder, name), 'utf8').catch(() => '');
+    for (const line of source.split('\n')) { try { const value = JSON.parse(line); if (typeof value.time === 'number' && typeof value.type === 'string') events.push(value); } catch {} }
+  }
+  events.sort((a, b) => a.time - b.time);
+  const recent = events.slice(-10000), groups = new Map(), entries = new Map();
+  for (const event of recent) {
+    if (event.type === 'cache' && typeof event.key === 'string') entries.set(event.key, { key: event.key, route: event.route, state: event.state, tags: event.tags || [], paths: event.paths || [], time: event.time });
+    if (!['http', 'fetch', 'cache'].includes(event.type)) continue;
+    const key = JSON.stringify([event.type, event.route, event.destination || null, event.state || null, event.reason || null]);
+    if (!groups.has(key)) groups.set(key, { type: event.type, route: event.route, destination: event.destination, state: event.state, reason: event.reason, count: 0, durations: [], errors: 0 });
+    const group = groups.get(key); group.count++; if (event.status >= 500 || event.error) group.errors++;
+    if (Number.isFinite(event.durationMs)) group.durations.push(event.durationMs);
+  }
+  const measurements = [...groups.values()].map(({ durations, ...group }) => {
+    durations.sort((a, b) => a - b);
+    return { ...group, ...(durations.length ? { meanMs: Math.round(durations.reduce((a, b) => a + b, 0) / durations.length * 100) / 100, p95Ms: durations[Math.ceil(durations.length * .95) - 1], maxMs: durations.at(-1) } : {}) };
+  }).sort((a, b) => (b.p95Ms || 0) - (a.p95Ms || 0));
+  return { version: 1, root, buildId: manifest.buildId, routes: manifest.routes.filter(route => !route.internal).map(route => explainRoute(route, manifest)),
+    measurements, cacheEntries: [...entries.values()].slice(-100), invalidations: recent.filter(event => event.type === 'invalidation').slice(-50), dynamicUsage: recent.filter(event => event.type === 'dynamic').slice(-50),
+    sample: { events: recent.length, from: recent[0]?.time, to: recent.at(-1)?.time },
+    notes: ['Enable measurements with prn start --inspect (or prn dev --inspect), visit routes, then run prn inspect again.',
+      'HTTP and fetch durations end when response headers are ready. Samples are bounded and can span server sessions; they are not full-response benchmarks.',
+      'Fetch destinations omit queries and credentials. Runtime cache tags/paths are hashed; matching identifiers link reads to invalidations. No diagnostic HTTP endpoint is exposed.'] };
+}
+export function printInspection(report) {
+  console.log(`PRNext inspector: ${report.root}`);
+  for (const route of report.routes) console.log(`${route.mode.padEnd(13)} ${route.pattern}\n  ${route.reasons.join('; ') || `${route.prerenderedPaths} prerendered path(s); revalidate: ${route.revalidate.join(', ') || 'on demand'}`}`);
+  for (const item of report.measurements) console.log(`${item.type.toUpperCase()} ${item.route}${item.destination ? ' -> ' + item.destination : ''}: ${item.count} sample(s)${item.state ? ', ' + item.state : ''}${item.reason ? ' (' + item.reason + ')' : ''}${item.p95Ms !== undefined ? ', p95 ' + item.p95Ms.toFixed(2) + ' ms' : ''}, ${item.errors} error(s)`);
+  for (const event of report.invalidations) console.log(`INVALIDATION ${event.route}: ${event.mode}; tags ${(event.tags || []).join(', ') || 'none'}; paths ${(event.paths || []).join(', ') || 'none'}`);
+  for (const event of report.cacheEntries) console.log(`CACHE ENTRY ${event.key} ${event.route}: ${event.state}; tags ${event.tags.join(', ') || 'none'}; paths ${event.paths.join(', ') || 'none'}`);
+  for (const message of new Set(report.dynamicUsage.map(event => `DYNAMIC ${event.route}: ${event.reason}`))) console.log(message);
+  for (const note of report.notes) console.log(note);
+}

package/build/loader-cache.mjs

@@ -1,6 +1,7 @@
+import { rename } from '../runtime/fs.mjs';
 import { createHash, randomUUID } from 'node:crypto';
 import { createRequire } from 'node:module';
-import { readFile, writeFile, mkdir, rename, rm, readdir, stat } from 'node:fs/promises';
+import { readFile, writeFile, mkdir, rm, readdir, stat } from 'node:fs/promises';
 import path from 'node:path';
 const require = createRequire(import.meta.url);
 const hash = value => createHash('sha256').update(value).digest('hex');

package/build/migrate.mjs

@@ -1,9 +1,10 @@
+import { rename } from '../runtime/fs.mjs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { randomUUID } from 'node:crypto';
 import { spawn } from 'node:child_process';
 import { constants } from 'node:fs';
-import { readFile, writeFile, rename, rm, lstat, realpath, access } from 'node:fs/promises';
+import { readFile, writeFile, rm, lstat, realpath, access } from 'node:fs/promises';
 import { checkProject } from './check.mjs';
 import { sourceCheckout } from '../native/resolve.mjs';
 
@@ -21,14 +22,22 @@ async function optionalFile(file) {
 export function parseMigrationArgs(args) {
   const options = { dryRun: false, install: true, json: false };
   let directory;
-  for (const arg of args) {
+  for (let index = 0; index < args.length; index++) {
+    const arg = args[index];
     if (arg === '--dry-run') options.dryRun = true;
+    else if (arg === '--check') options.check = true;
+    else if (['--against', '--candidate', '--routes', '--timeout'].includes(arg)) {
+      const value = args[++index];
+      if (!value || value.startsWith('--')) throw new Error(`${arg} requires a value.`);
+      options[arg.slice(2)] = arg === '--timeout' ? Number(value) : value;
+    }
     else if (arg === '--no-install') options.install = false;
     else if (arg === '--json') options.json = true;
-    else if (arg.startsWith('-')) throw new Error(`Unknown migrate option: ${arg}. Use --dry-run, --no-install or --json.`);
+    else if (arg.startsWith('-')) throw new Error(`Unknown migrate option: ${arg}. Use --check, --dry-run, --no-install or --json.`);
     else if (directory === undefined) directory = arg;
     else throw new Error('migrate accepts a single project directory.');
   }
+  if ((options.against || options.candidate || options.routes || options.timeout !== undefined) && (!options.check || !options.against || !options.candidate)) throw new Error('Server comparison requires --check, --against and --candidate.');
   return { directory: path.resolve(directory || '.'), options };
 }
 
@@ -52,13 +61,15 @@ function words(script) {
 }
 
 export function migrateScript(script, command) {
-  if (script === undefined) return { value: `prn ${command}`, removed: [] };
+  // PRN is a reserved device name in older Windows shells. Generated scripts
+  // must remain portable even when migration runs on another operating system.
+  if (script === undefined) return { value: `prnext ${command}`, removed: [] };
   if (typeof script !== 'string') throw new Error(`scripts.${command} must be a string.`);
   // Existing PRNext scripts, including customized wrappers, are not rewritten.
   if (/^(?:prn|prnext)\s+/.test(script.trim())) return { value: script, removed: [] };
   let tokens;
   try { tokens = words(script); }
-  catch (error) { throw new Error(`scripts.${command} ${error.message}. Adapt it to prn ${command} manually before migrating; no scripts were overwritten.`); }
+  catch (error) { throw new Error(`scripts.${command} ${error.message}. Adapt it to prnext ${command} manually before migrating; no scripts were overwritten.`); }
   const prefix = [];
   let environmentPort;
   if (tokens[0]?.value === 'cross-env') prefix.push(tokens.shift().raw);
@@ -73,11 +84,11 @@ export function migrateScript(script, command) {
   }
   const executable = tokens.shift()?.value;
   if (!['next', 'rx'].includes(executable) || tokens.shift()?.value !== command) {
-    throw new Error(`scripts.${command} is customized. Adapt it to prn ${command} manually before migrating; no scripts were overwritten.`);
+    throw new Error(`scripts.${command} is customized. Adapt it to prnext ${command} manually before migrating; no scripts were overwritten.`);
   }
   // Upgrade the former shortcut without interpreting its native PRNext options
   // as Next.js bundler flags. Complex shell programs still require a manual edit.
-  if (executable === 'rx') return { value: [...prefix, 'prn', command, ...tokens.map(token => token.raw)].join(' '), removed: [] };
+  if (executable === 'rx') return { value: [...prefix, 'prnext', command, ...tokens.map(token => token.raw)].join(' '), removed: [] };
   const kept = [], removed = [];
   let directory = false, explicitPort = false;
   for (let i = 0; i < tokens.length; i++) {
@@ -105,7 +116,7 @@ export function migrateScript(script, command) {
     if (!/^\d+$/.test(environmentPort) || Number(environmentPort) > 65535) throw new Error(`scripts.${command}: PORT must be a literal port number. Adapt the script before migrating.`);
     kept.push('--port', environmentPort);
   }
-  return { value: [...prefix, 'prn', command, ...kept].join(' '), removed };
+  return { value: [...prefix, 'prnext', command, ...kept].join(' '), removed };
 }
 
 export function migrationPackage(input, framework, spec) {

package/build/migration-audit.mjs

@@ -0,0 +1,126 @@
+import { parse } from '@babel/parser';
+import { readdir, readFile, stat } from 'node:fs/promises';
+import path from 'node:path';
+import { createHash } from 'node:crypto';
+import { checkProject } from './check.mjs';
+import { frameworkImportName } from './framework-imports.mjs';
+import { packageManifest } from '../native/resolve.mjs';
+
+const supported = new Set([...Object.keys(packageManifest.exports).map(name => name.slice(2)), 'font/google', 'font/local', 'next-router-context', 'next-app-router-context']);
+const ignored = new Set(['node_modules', '.git', '.next', '.prnext', '.prnext-cache', 'dist', 'build', 'out', 'coverage', 'test-results', '__tests__']);
+const code = /\.(?:[cm]?[jt]s|[jt]sx)$/;
+function walkAst(node, visit) {
+  if (!node || typeof node !== 'object') return;
+  if (typeof node.type === 'string') visit(node);
+  for (const [key, value] of Object.entries(node)) {
+    if (['loc', 'comments', 'tokens', 'extra'].includes(key)) continue;
+    if (Array.isArray(value)) for (const child of value) walkAst(child, visit);
+    else if (value && typeof value === 'object') walkAst(value, visit);
+  }
+}
+
+/** A bounded source audit. It never runs a build, installs packages, or edits the project. */
+export async function auditMigration(directory) {
+  const root = path.resolve(directory);
+  const preflight = await checkProject(root, { validateDependencies: false });
+  const report = { version: 1, root, ok: false, status: 'checked', files: 0, routes: preflight.routes,
+    versions: preflight.versions, findings: [], imports: [], notes: [
+      'This source audit does not execute application routes or inspect every installed dependency. Run a production build and browser tests before switching.',
+      'Configuration files are evaluated by preflight. Application sources and package files are not modified.',
+    ] };
+  const finding = (severity, id, file, line, message, action) => report.findings.push({ severity, id, file, line, message, action });
+  for (const error of preflight.errors) finding('error', 'preflight', null, null, error, 'Fix the configuration or route convention, then run the check again.');
+  let bytes = 0;
+  async function scan(dir) {
+    for (const item of (await readdir(dir, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name))) {
+      if (ignored.has(item.name) || item.name.startsWith('.prnext-')) continue;
+      const filename = path.join(dir, item.name), file = path.relative(root, filename).split(path.sep).join('/');
+      if (item.isSymbolicLink()) { finding('warning', 'linked-source', file, null, 'Linked source was not scanned.', 'Check the linked package during the production build.'); continue; }
+      if (item.isDirectory()) { await scan(filename); continue; }
+      if (!item.isFile() || !code.test(item.name) || /(?:\.d|\.test|\.spec)\.[cm]?[jt]sx?$/.test(item.name)) continue;
+      if (++report.files > 5000 || (bytes += (await stat(filename)).size) > 32 * 1024 ** 2) throw new Error('Source audit exceeds 5000 files or 32 MiB. Choose the application directory.');
+      const source = await readFile(filename, 'utf8');
+      let ast;
+      try { ast = parse(source, { sourceType: 'unambiguous', plugins: ['jsx', ...( /\.[cm]?tsx?$/.test(item.name) ? ['typescript'] : []), 'decorators-legacy'] }); }
+      catch (error) { finding('warning', 'source-syntax', file, error.loc?.line || 1, 'The audit could not parse this source file.', 'Validate it with the production compiler; custom loaders may be required.'); continue; }
+      const client = ast.program.directives.some(directive => directive.value.value === 'use client');
+      walkAst(ast.program, node => {
+        const specifier = ['ImportDeclaration', 'ExportNamedDeclaration', 'ExportAllDeclaration'].includes(node.type) && node.importKind !== 'type' && node.exportKind !== 'type' ? node.source?.value
+          : node.type === 'CallExpression' && (node.callee.type === 'Import' || node.callee.name === 'require') ? node.arguments[0]?.value : undefined;
+        if (typeof specifier !== 'string' || !(specifier === 'next' || specifier.startsWith('next/'))) return;
+        if (node.type === 'ImportDeclaration' && node.specifiers.length && node.specifiers.every(value => value.importKind === 'type')) return;
+        const name = frameworkImportName(specifier), available = supported.has(name);
+        report.imports.push({ file, line: node.loc.start.line, specifier, supported: available });
+        if (!available) finding('error', 'unsupported-import', file, node.loc.start.line, `No PRNext runtime adapter for ${specifier}.`, 'Replace this import with a supported public API or keep this route on Next.js.');
+        else if (client && ['headers', 'cache', 'server', 'og'].includes(name)) finding('error', 'server-import-in-client', file, node.loc.start.line, `${specifier} is imported by a client module.`, 'Move the server operation into a Server Component or Server Action.');
+      });
+    }
+  }
+  try { await scan(root); }
+  catch (error) { finding('error', 'scan-incomplete', null, null, error.message, 'Resolve the file access or size limit and run the check again.'); }
+  let pkg = {};
+  try { pkg = JSON.parse(await readFile(path.join(root, 'package.json'), 'utf8')); }
+  catch (error) { finding('error', 'package-json', 'package.json', null, error.message, 'Provide a valid package.json in the application directory.'); }
+  const { migrateScript } = await import('./migrate.mjs');
+  for (const command of ['dev', 'build', 'start']) {
+    try { migrateScript(pkg.scripts?.[command], command); }
+    catch (error) { finding('warning', 'custom-script', 'package.json', null, error.message, `Keep a backup of the command and adapt scripts.${command} manually.`); }
+  }
+  const expected = packageManifest.peerDependencies;
+  for (const name of ['react', 'react-dom', ...(report.routes.some(route => route.router === 'app') ? ['react-server-dom-webpack'] : [])]) {
+    if (report.versions[name] !== expected[name]) finding('warning', 'react-version', 'package.json', null, `${name}: ${report.versions[name] || 'not installed'}; PRNext expects ${expected[name]}.`, 'Review the dependency changes with prn migrate --dry-run.');
+  }
+  report.ok = !report.findings.some(item => item.severity === 'error');
+  return report;
+}
+
+function origin(value) {
+  const url = new URL(value);
+  if (!['http:', 'https:'].includes(url.protocol) || url.username || url.password || url.pathname !== '/' || url.search || url.hash) throw new Error('Comparison servers must be HTTP(S) origins without credentials, paths, or queries.');
+  return url.origin;
+}
+const canonical = value => Array.isArray(value) ? value.map(canonical) : value && typeof value === 'object'
+  ? Object.fromEntries(Object.keys(value).sort().map(key => [key, canonical(value[key])])) : value;
+export function comparableBody(body, type) {
+  if (type.includes('json')) return JSON.stringify(canonical(JSON.parse(body)));
+  if (type.includes('html')) return body.replace(/<(script|style)\b[^>]*>[\s\S]*?<\/\1\s*>/gi, '').replace(/<!--[\s\S]*?-->/g, '')
+    .replace(/<[^>]*>/g, ' ').replace(/\s+/g, ' ').trim();
+  return body;
+}
+async function probe(base, route, timeout) {
+  const started = performance.now();
+  const response = await fetch(base + route, { redirect: 'manual', signal: AbortSignal.timeout(timeout) });
+  const headersMs = performance.now() - started;
+  let size = 0;
+  const chunks = [];
+  if (response.body) for await (const chunk of response.body) {
+    if ((size += chunk.length) > 2 * 1024 ** 2) throw new Error('Comparison response exceeds 2 MiB.');
+    chunks.push(chunk);
+  }
+  const type = (response.headers.get('content-type') || '').split(';')[0].toLowerCase();
+  const location = response.headers.get('location');
+  const target = location ? new URL(location, base + route) : null;
+  const bytes = Buffer.concat(chunks);
+  const body = type.includes('json') || type.includes('html') || type.startsWith('text/') ? comparableBody(bytes.toString('utf8'), type) : bytes;
+  return { status: response.status, type, redirect: target ? (target.origin === base ? '' : target.origin) + target.pathname + target.search + target.hash : null,
+    bodySha256: createHash('sha256').update(body).digest('hex'), bytes: size, headersMs: Math.round(headersMs * 100) / 100,
+    totalMs: Math.round((performance.now() - started) * 100) / 100, cacheControl: response.headers.get('cache-control') };
+}
+export async function compareServers({ against, candidate, routes, timeout = 10000 }) {
+  const reference = origin(against), current = origin(candidate);
+  if (!Array.isArray(routes) || !routes.length || routes.length > 100 || routes.some(route => typeof route !== 'string' || !route.startsWith('/') || route.startsWith('//') || /[\\\r\n#]/.test(route) || new URL(route, reference).origin !== reference)) throw new Error('Provide 1–100 local URL paths, including concrete values for dynamic routes.');
+  if (!Number.isInteger(timeout) || timeout < 100 || timeout > 60000) throw new Error('Comparison timeout must be 100–60000 milliseconds.');
+  const results = [];
+  for (const route of [...new Set(routes)]) {
+    const values = await Promise.allSettled([probe(reference, route, timeout), probe(current, route, timeout)]);
+    if (values.some(value => value.status === 'rejected')) {
+      results.push({ route, equal: false, error: values.map((value, index) => value.status === 'rejected' ? `${index ? 'candidate' : 'reference'}: ${value.reason.message}` : null).filter(Boolean).join('; ') });
+      continue;
+    }
+    const [before, after] = values.map(value => value.value);
+    const differences = ['status', 'type', 'redirect', 'bodySha256'].filter(key => before[key] !== after[key]);
+    results.push({ route, equal: differences.length === 0, differences, reference: before, candidate: after });
+  }
+  return { ok: results.every(result => result.equal), reference, candidate: current, results,
+    scope: 'GET status, content type, redirect target and body comparison. HTML compares text without scripts/styles; JSON ignores object key order. Headers timings are observations, not a benchmark. Browser behavior and authenticated requests require separate tests.' };
+}

package/build/precompress.mjs

@@ -1,5 +1,6 @@
+import { rename } from '../runtime/fs.mjs';
 import { createReadStream, createWriteStream } from 'node:fs';
-import { readdir, rm, stat, utimes, mkdir, copyFile, rename } from 'node:fs/promises';
+import { readdir, rm, stat, utimes, mkdir, copyFile } from 'node:fs/promises';
 import path from 'node:path';
 import { pipeline } from 'node:stream/promises';
 import { createGzip, createGunzip } from 'node:zlib';

package/build/standalone-runner.mjs

@@ -6,7 +6,7 @@ export async function prepareStandalone(options) {
   const { output, distDir, outputFileTracingRoot, outputFileTracingIncludes, outputFileTracingExcludes } = options.config;
   const worker = new Worker(new URL('./standalone-worker.mjs', import.meta.url), {
     workerData: { ...options, config: { output, distDir, outputFileTracingRoot, outputFileTracingIncludes, outputFileTracingExcludes } },
-    execArgv: process.execArgv.filter(argument => !argument.startsWith('--input-type')),
+    execArgv: [],
   });
   try {
     await new Promise((resolve, reject) => {