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

package/build/standalone.mjs

@@ -1,7 +1,7 @@
 import { nodeFileTrace } from '@vercel/nft';
 import resolver from '@vercel/nft/out/resolve-dependency.js';
 import picomatch from 'picomatch';
-import { mkdir, readFile, writeFile, readdir, realpath, readlink, stat, lstat, copyFile, chmod, symlink } from 'node:fs/promises';
+import { mkdir, readFile, writeFile, readdir, realpath, readlink, stat, lstat, copyFile, chmod, symlink, cp } from 'node:fs/promises';
 import path from 'node:path';
 import { resolveNativeBinary } from '../native/resolve.mjs';
 import { createHash } from 'node:crypto';
@@ -13,6 +13,15 @@ const missing = error => error.code === 'ENOENT' || error.code === 'ENOTDIR';
 const maxFiles = 100_000;
 const maxBytes = 2 * 1024 ** 3;
 
+export async function resolveTraceDependency(...args) {
+  const result = await resolver.default(...args);
+  // NFT can return mixed separators for scoped packages on Windows. Its
+  // realpath traversal only normalizes paths on the tracing base's drive;
+  // other drives would then get the wrong package.json boundary.
+  const normalize = file => file.startsWith('node:') ? file : path.normalize(file);
+  return Array.isArray(result) ? result.map(normalize) : normalize(result);
+}
+
 function patternsFor(rules, route) {
   return Object.entries(rules || {}).flatMap(([key, values]) => picomatch(key, { dot: true })(route) ? values : []);
 }
@@ -66,9 +75,20 @@ export async function createStandalone({ projectRoot, stage, manifest, config })
   const warnings = new Set();
   let omittedWarnings = 0;
   const cache = {};
+  const traceLocations = new Map();
   let traceReads = 0;
   let traceBytes = 0;
 
+  function traceLocation(file) {
+    if (!traceLocations.has(file)) traceLocations.set(file, (async () => {
+      // Expand Windows 8.3 names and filesystem casing, preserving the final
+      // symlink itself so workspace links can still be relocated portably.
+      if ((await lstat(file)).isSymbolicLink()) return path.join(await realpath(path.dirname(file)), path.basename(file));
+      return realpath(file);
+    })());
+    return traceLocations.get(file);
+  }
+
   function relocated(file) {
     if (within(stage, file)) return path.join(appOutput, config.distDir, path.relative(stage, file));
     if (within(tracingRoot, file)) return path.join(output, 'app', path.relative(tracingRoot, file));
@@ -109,19 +129,19 @@ export async function createStandalone({ projectRoot, stage, manifest, config })
           return readFile(file);
         },
         async resolve(specifier, parent, job, cjs) {
-          const resolved = await resolver.default(specifier, parent, job, cjs);
+          const resolved = await resolveTraceDependency(specifier, parent, job, cjs);
           if (!specifier.startsWith('.') && !specifier.startsWith('#') && !path.isAbsolute(specifier) && !specifier.startsWith('node:')) {
             const name = specifier.split('/').slice(0, specifier.startsWith('@') ? 2 : 1).join('/');
             for (const file of Array.isArray(resolved) ? resolved : [resolved]) {
               if (file.startsWith('node:')) continue;
               const owner = await packageRoot(file, name);
-              if (owner) bridges.set(path.join(path.dirname(parent), 'node_modules', name), owner);
+              if (owner) bridges.set(path.join(path.dirname(await realpath(parent)), 'node_modules', name), await realpath(owner));
             }
           }
           return resolved;
         },
       });
-      for (const file of result.fileList) traceFiles.add(path.resolve(path.parse(projectRoot).root, file));
+      for (const file of result.fileList) traceFiles.add(await traceLocation(path.resolve(path.parse(projectRoot).root, file)));
       for (const warning of result.warnings) {
         const message = warning.message.replaceAll(projectRoot, '<project>').slice(0, 2048);
         if (warnings.has(message)) continue;
@@ -185,8 +205,14 @@ export async function createStandalone({ projectRoot, stage, manifest, config })
   let copiedFiles = 0;
   const pendingLinks = [];
   for (const source of traceFiles) {
-    const target = relocated(source);
     const info = await lstat(source);
+    // NFT also emits ancestor aliases used by absolute workspace links, such as
+    // macOS /var -> /private/var. Their canonical children are already traced;
+    // these host directory aliases are not dependencies of the artifact.
+    // Real files and links to unrelated external workspaces still go through
+    // relocated(), which enforces the configured tracing boundary.
+    if (info.isSymbolicLink() && !within(tracingRoot, source) && within(await realpath(source), tracingRoot)) continue;
+    const target = relocated(source);
     if (++copiedFiles > maxFiles || (copiedBytes += info.size) > maxBytes) throw new Error('Standalone output exceeds 100000 files / 2 GiB. Narrow tracing includes.');
     if (info.isSymbolicLink()) {
       const destination = await realpath(source);
@@ -203,9 +229,35 @@ export async function createStandalone({ projectRoot, stage, manifest, config })
   for (const [source, owner] of bridges) {
     // An excluded optional dependency must not be brought back by a bridge.
     if (!includedOwners.has(owner)) continue;
-    pendingLinks.push([relocated(source), relocated(owner)]);
+    const marker = `${path.sep}node_modules${path.sep}`;
+    const offset = source.lastIndexOf(marker);
+    pendingLinks.push([relocated(source), relocated(owner), source.slice(offset + marker.length), relocated(source.slice(0, offset))]);
   }
-  for (const [link, target] of pendingLinks) {
+  const materialized = new Map();
+  const dependencyLinks = pendingLinks.filter(([, , packageName]) => packageName);
+  function original(file) {
+    for (const [copy, source] of materialized) {
+      if (within(copy, file)) return original(path.join(source, path.relative(copy, file)));
+    }
+    return file;
+  }
+  for (let [link, target, packageName, importer] of pendingLinks) {
+    if (process.platform === 'win32' && packageName) {
+      // Reuse Node's ancestor lookup before copying a bridge. Install shared
+      // hoisted dependencies once, keeping React and package singletons intact.
+      const search = createRequire(path.join(importer, '__prnext_trace.cjs')).resolve.paths(packageName)
+        .map(directory => path.join(directory, packageName)).filter(file => within(output, file));
+      const vacant = [];
+      let found;
+      for (const candidate of search) {
+        try { await lstat(candidate); found = candidate; break; }
+        catch (error) { if (!missing(error)) throw error; vacant.push(candidate); }
+      }
+      if (found && original(found) === original(target)) continue;
+      // If a nearer version shadows this owner, add the bridge before it.
+      link = found ? vacant[0] : vacant.at(-1);
+      if (!link) throw new Error(`Conflicting standalone dependency ${packageName} at ${importer}.`);
+    }
     if (link === target) continue;
     await mkdir(path.dirname(link), { recursive: true });
     try {
@@ -214,7 +266,26 @@ export async function createStandalone({ projectRoot, stage, manifest, config })
       if (current.isSymbolicLink() && path.resolve(path.dirname(link), await readlink(link)) === target) continue;
       throw new Error(`Conflicting standalone dependency at ${path.relative(output, link)}.`);
     } catch (error) { if (!missing(error)) throw error; }
-    await symlink(path.relative(path.dirname(link), target), link, (await stat(target)).isDirectory() ? 'dir' : 'file');
+    if (process.platform === 'win32') {
+      // Junctions contain absolute targets and break when an artifact moves;
+      // symlinks require privileges. Copy only the already traced files.
+      await cp(target, link, { recursive: true, dereference: true, async filter(source) {
+        const info = await stat(source);
+        if (info.isFile() && (++copiedFiles > maxFiles || (copiedBytes += info.size) > maxBytes)) throw new Error('Standalone output exceeds 100000 files / 2 GiB. Narrow tracing includes.');
+        return true;
+      } });
+      materialized.set(link, target);
+      // A copied workspace package no longer resolves through its real path.
+      // Give imports inside that copy the same dependency owners as the source.
+      for (const [dependency, owner, name, parent] of dependencyLinks) {
+        if (within(target, parent)) pendingLinks.push([
+          path.join(link, path.relative(target, dependency)), owner, name,
+          path.join(link, path.relative(target, parent)),
+        ]);
+      }
+    } else {
+      await symlink(path.relative(path.dirname(link), target), link, (await stat(target)).isDirectory() ? 'dir' : 'file');
+    }
   }
   const binaryName = process.platform === 'win32' ? 'prnext.exe' : 'prnext';
   const binary = await resolveNativeBinary();
@@ -230,7 +301,7 @@ export async function createStandalone({ projectRoot, stage, manifest, config })
   await writeFile(path.join(appOutput, 'package.json'), packageJson);
   const relativeApp = slash(path.relative(output, appOutput));
   await writeFile(path.join(output, 'package.json'), '{"private":true,"type":"commonjs"}\n');
-  await writeFile(path.join(output, 'server.js'), `'use strict';\nconst path=require('node:path');const {spawn}=require('node:child_process');\nconst root=path.join(__dirname,${JSON.stringify(relativeApp)});\nconst child=spawn(path.join(__dirname,'bin',${JSON.stringify(binaryName)}),['start',root,'--hostname',process.env.HOSTNAME||'0.0.0.0','--port',process.env.PORT||'3000','--workers',process.env.PRNEXT_WORKERS||'1','--node',process.execPath],{cwd:root,stdio:'inherit',env:{...process.env,NODE_ENV:'production'}});\nfor(const signal of ['SIGINT','SIGTERM'])process.on(signal,()=>child.kill(signal));\nchild.on('error',error=>{console.error(error.message);process.exitCode=1;});child.on('exit',(code,signal)=>{process.exitCode=code??(signal==='SIGINT'?130:signal==='SIGTERM'?143:1);});\n`);
+  await writeFile(path.join(output, 'server.js'), `'use strict';\nconst path=require('node:path');const {spawn}=require('node:child_process');\nconst root=path.join(__dirname,${JSON.stringify(relativeApp)});\nconst child=spawn(path.join(__dirname,'bin',${JSON.stringify(binaryName)}),['start',root,'--hostname',process.env.HOSTNAME||'0.0.0.0','--port',process.env.PORT||'3000','--workers',process.env.PRNEXT_WORKERS||'1','--node',process.execPath,...(process.platform==='win32'?['--shutdown-on-stdin-eof']:[])],{cwd:root,stdio:process.platform==='win32'?['pipe','inherit','inherit']:'inherit',windowsHide:true,env:{...process.env,NODE_ENV:'production'}});\nfor(const signal of ['SIGINT','SIGTERM'])process.on(signal,()=>{if(process.platform==='win32')child.stdin.end();else child.kill(signal)});\nchild.on('error',error=>{console.error(error.message);process.exitCode=1;});child.on('exit',(code,signal)=>{process.exitCode=code??(signal==='SIGINT'?130:signal==='SIGTERM'?143:1);});\n`);
   if (process.platform !== 'win32') {
     const quotedApp = "'" + relativeApp.replaceAll("'", "'\\''") + "'";
     await writeFile(path.join(output, 'start'), `#!/bin/sh\nset -eu\nSELF=$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)\ncd "$SELF/"${quotedApp}\nexec "$SELF/bin/prnext" start . --hostname "\${HOSTNAME:-0.0.0.0}" --port "\${PORT:-3000}" --workers "\${PRNEXT_WORKERS:-1}" --node "\${PRNEXT_NODE:-node}" "$@"\n`);

package/build/static-export.mjs

@@ -1,4 +1,5 @@
-import { mkdir, readFile, writeFile, cp, readdir, lstat, rename, rm } from 'node:fs/promises';
+import { rename } from '../runtime/fs.mjs';
+import { mkdir, readFile, writeFile, cp, readdir, lstat, rm } from 'node:fs/promises';
 import path from 'node:path';
 import { randomUUID } from 'node:crypto';
 

package/cli.mjs

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
+import { rename } from './runtime/fs.mjs';
 import { spawn } from 'node:child_process';
-import { readFile, writeFile, rename, rm } from 'node:fs/promises';
+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';
@@ -11,20 +12,34 @@ const self = fileURLToPath(import.meta.url);
 const [command = 'help', ...argv] = process.argv.slice(2);
 const help = `PRNext ${packageManifest.version}
 
-Use prnext or prn: both names run the same CLI.
+Use prnext for portable scripts; prn is a shortcut on compatible shells.
 
-  prnext build [directory]             Build React/TypeScript and static HTML
-  prnext start [directory] [options]   Start native Rust production server
-  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
-  prn migrate [directory] [options]   Migrate a Next project's scripts and dependencies
+  prnext build [directory]              Build React/TypeScript and static HTML
+  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
+  prnext pstop [name] [--all]            Stop persistent apps
+  prnext pstatus [--json]               Show persistent app status (alias: plist)
+  prnext plogs [name] [--follow]         Read persistent app logs
+  prnext pstartup [--remove]            Configure restoration at user login
+  prnext pstart --help                  All persistent commands and options
+  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 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
 
 Migration options: --dry-run (preview), --no-install (prepare only), --json
+  prnext migrate --check                Audit source compatibility without migrating
+  prnext migrate --check --against URL --candidate URL [--routes paths.json]
+                                       Compare GET responses before switching
 Migration keeps Next.js and backs up package.json and existing lockfiles.
-Simple next dev/build/start scripts become prn commands; custom shell scripts need a manual edit.
+Simple next dev/build/start scripts become prnext commands; custom shell scripts need a manual edit.
 
-Server options: --port 3000 --hostname 127.0.0.1 --workers 1
+Server options: --port 3000 --hostname 127.0.0.1 --workers 1 --inspect
 Production profiles: --profile balanced|speed|memory|classic
 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.
@@ -45,17 +60,68 @@ function stop(child) {
   return new Promise(resolve => {
     const timer = setTimeout(() => child.kill('SIGKILL'), 5000);
     child.once('exit', () => { clearTimeout(timer); resolve(); });
-    child.kill('SIGTERM');
+    if (child.stdin) child.stdin.end();
+    else child.kill('SIGTERM');
   });
 }
 
 async function main() {
   if (['help', '--help', '-h'].includes(command)) { console.log(help); return; }
   if (['--version', '-v'].includes(command)) { console.log(packageManifest.version); 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);
+    return;
+  }
+  if (command === 'host') {
+    if (argv.includes('--help') || argv.includes('-h')) { console.log(help); return; }
+    const files = argv.filter(arg => !arg.startsWith('-'));
+    if (files.length > 1 || argv.some(arg => arg.startsWith('-') && !['--status', '--json', '--check'].includes(arg))) throw new Error('host accepts [config], --check, or --status [--json]');
+    const config = path.resolve(files[0] || 'prnext.host.json');
+    if (argv.includes('--status') && argv.includes('--check')) throw new Error('Choose --check or --status for the host command.');
+    if (argv.includes('--status')) {
+      const info = path.parse(config);
+      const report = JSON.parse(await readFile(path.join(info.dir, info.name + '.status.json'), 'utf8'));
+      report.snapshotAgeMs = Date.now() - report.time;
+      if (argv.includes('--json')) console.log(JSON.stringify(report, null, 2));
+      else {
+        console.log(`PRNext host: ${report.reservedMb}/${report.memoryMb} MiB reserved; snapshot ${Math.round(report.snapshotAgeMs / 1000)}s ago${report.stopping ? ' (stopped)' : ''}`);
+        for (const app of report.apps) console.log(`${app.name}: ${app.state}, ${(app.rssBytes / 1024 / 1024).toFixed(1)}/${app.memoryMb} MiB RSS, ${app.activeRequests} active request(s), ${app.starts} start(s) — ${app.reason}`);
+      }
+      return;
+    }
+    if (argv.includes('--json')) throw new Error('--json requires --status');
+    const binary = await resolveNativeBinary();
+    const child = spawn(binary, ['host', config, '--node', process.execPath, '--shutdown-on-stdin-eof', ...(argv.includes('--check') ? ['--check'] : [])], { stdio: ['pipe', 'inherit', 'inherit'], windowsHide: true });
+    const shutdown = () => child.stdin.end();
+    process.once('SIGINT', shutdown); process.once('SIGTERM', shutdown);
+    await done(child);
+    return;
+  }
   if (command === 'migrate') {
     if (argv.includes('--help') || argv.includes('-h')) { console.log(help); return; }
     const { parseMigrationArgs, migrateProject } = await import('./build/migrate.mjs');
     const { directory, options } = parseMigrationArgs(argv);
+    if (options.check) {
+      const { auditMigration, compareServers } = await import('./build/migration-audit.mjs');
+      const report = await auditMigration(directory);
+      if (options.against) {
+        const routes = options.routes ? JSON.parse(await readFile(path.resolve(options.routes), 'utf8'))
+          : report.routes.filter(route => route.kind === 'page' && !route.pattern.includes('[')).map(route => route.pattern);
+        report.comparison = await compareServers({ ...options, routes });
+        report.ok &&= report.comparison.ok;
+      }
+      if (options.json) console.log(JSON.stringify(report, null, 2));
+      else {
+        console.log(`PRNext migration check ${report.ok ? 'passed' : 'failed'}: ${directory}`);
+        console.log(`${report.files} source files; ${report.routes.length} routes.`);
+        for (const item of report.findings) console.log(`${item.severity.toUpperCase()} ${item.file || 'project'}${item.line ? ':' + item.line : ''}: ${item.message}\n  ${item.action}`);
+        for (const result of report.comparison?.results || []) console.log(`${result.equal ? 'MATCH' : 'DIFFERENT'} ${result.route}: ${result.error || result.differences.join(', ') || 'responses match'}`);
+        for (const note of [...report.notes, ...(report.comparison ? [report.comparison.scope] : [])]) console.log(note);
+      }
+      if (!report.ok) process.exitCode = 1;
+      return;
+    }
     const report = await migrateProject(directory, options);
     if (options.json) console.log(JSON.stringify(report, null, 2));
     else {
@@ -64,14 +130,25 @@ async function main() {
       for (const backup of report.backups) console.log(`Backup: ${backup}`);
       for (const note of report.notes) console.log(note);
       if (report.error) console.error(report.error);
-      if (report.ok && !options.dryRun) console.log(options.install ? 'Next: npm run build, then npm start (or npm run dev).' : 'Next: install dependencies with your package manager, then prn check and prn build.');
+      if (report.ok && !options.dryRun) console.log(options.install ? 'Next: npm run build, then npm start (or npm run dev).' : 'Next: install dependencies with your package manager, then prnext check and prnext build.');
     }
     if (!report.ok) process.exitCode = 1;
     return;
   }
-  if (!['build', 'start', 'dev', 'routes', 'check'].includes(command)) throw new Error(`Unknown command: ${command}\n${help}`);
+  if (!['build', 'start', 'dev', 'routes', 'check', 'inspect'].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 === 'inspect') {
+    if (args.some(arg => arg !== '--json')) throw new Error('inspect accepts only [directory] and --json');
+    const { inspectProject, printInspection } = await import('./build/inspect.mjs');
+    const report = await inspectProject(root);
+    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');
+  }
   if (command === 'build' || command === 'dev') {
     // Build plugins such as Contentlayer read cwd/INIT_CWD rather than webpack's
     // context. Explicit application directories must behave like `cd app`.
@@ -107,7 +184,8 @@ async function main() {
   const binary = await resolveNativeBinary();
   let outputDirectory = await readBuildDirectory(root);
   const launch = () => spawn(binary, [command === 'routes' ? 'routes' : 'start', root,
-    ...(command === 'routes' ? [] : ['--worker', path.join(root, outputDirectory, 'runtime/worker.mjs')]), ...args], { stdio: 'inherit', env: { ...process.env, NODE_ENV: process.env.NODE_ENV || (command === 'dev' ? 'development' : 'production') } });
+    ...(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') } });
   let server;
   let stopping = false;
   let watcher;
@@ -149,11 +227,13 @@ async function main() {
     let buildOutput = '';
     try {
       const actualChanges = await filterChanges(pending);
+      if (stopping) return;
       if (attempted && !actualChanges.length) return;
       attempted = true;
       const changed = actualChanges.slice(0, 32).map(file => file.slice(0, 256));
       await notifyDev({ state: 'building' });
       if (actualChanges.some(file => /(?:^|\/)(?:(?:next|prnext|contentlayer)\.config\.|package(?:-lock)?\.json$|(?:pnpm-lock\.yaml|yarn\.lock)$)/.test(file))) { await stop(rebuildChild); rebuildChild = undefined; }
+      if (stopping) return;
       if (!rebuildChild || rebuildChild.exitCode !== null || rebuildChild.signalCode) {
         rebuildChild = spawn(process.execPath, [path.join(path.dirname(self), 'build/dev-worker.mjs')], { stdio: ['inherit', 'pipe', 'pipe', 'ipc'], env: { ...process.env, NODE_ENV: process.env.NODE_ENV || 'development' } });
       }
@@ -179,6 +259,9 @@ async function main() {
         await stop(server);
         outputDirectory = await readBuildDirectory(root);
         await watcher.refresh();
+        // Shutdown can arrive while the previous server is draining. Never
+        // leave a replacement running after shutdown already stopped its peers.
+        if (stopping) return;
         for (const file of changedFiles) {
           if (file === outputDirectory || file.startsWith(outputDirectory + '/') || outputDirectory.startsWith(file + '/')) changedFiles.delete(file);
         }
@@ -186,6 +269,7 @@ async function main() {
         server = launch();
         server.on('error', error => console.error(`PRNext server: ${error.message}`));
         const manifest = JSON.parse(await readFile(path.join(root, outputDirectory, 'manifest.json'), 'utf8'));
+        if (stopping) return;
         await notifyDev({ state: 'ready', buildId: manifest.buildId, clientManifest: manifest.devClient, changed });
         console.log('Source compiled. React Fast Refresh applied in connected browsers.');
       }
@@ -197,6 +281,7 @@ async function main() {
     ignore: relative => relative === outputDirectory || relative.startsWith(outputDirectory + '/'),
     onError: error => { console.error(`PRNext development watcher: ${error.message}`); process.exitCode = 1; void shutdown(); },
     onChange: filename => {
+    if (stopping) return;
     const relative = String(filename || '').replaceAll(path.sep, '/');
     if (relative === outputDirectory || relative.startsWith(outputDirectory + '/') || !shouldWatchProjectFile(filename)) return;
     changedFiles.add(String(filename).replaceAll(path.sep, '/'));
@@ -204,6 +289,7 @@ async function main() {
     timer = setTimeout(() => { if (changedFiles.size) void rebuild(); }, 150);
     },
   });
+  if (stopping) { watcher.close(); return; }
   await rebuild();
 }
 

package/compat/cache-handlers.cjs

@@ -134,7 +134,9 @@ async function customCachedValue(key, kind, producer, options) {
   let work = joined?.work;
   if (!work) {
     const revision = revisions.get(handler) || 0;
-    const timestamp = performance.timeOrigin + performance.now();
+    // Handler invalidations use wall-clock timestamps. On Windows the
+    // performance clock can run ahead of Date.now(), hiding a later update.
+    const timestamp = Date.now();
     const record = { revision, timestamp, work: undefined, metadata: undefined };
     work = (async () => {
       const result = await producer();

package/compat/data-cache.cjs

@@ -3,6 +3,7 @@ const { AsyncLocalStorage, AsyncResource } = require('node:async_hooks');
 const http = require('node:http');
 const { setTimeout: delay } = require('node:timers/promises');
 const { trackStaticDependency } = require('./static-generation.cjs');
+const diagnostics = require('./diagnostics.cjs');
 
 // Capture before the runtime installs its application-facing fetch wrapper.
 const nativeFetchSymbol = Symbol.for('prnext.nativeFetch');
@@ -309,12 +310,16 @@ async function cachedValue(key, producer, options = {}) {
   if (state) await state.invalidations;
   throwIfAborted(signal);
   if (options.incremental && (context?.cacheHandler || context?.manifest?.config?.cacheHandler)) {
+    if (diagnostics.enabled) diagnostics.record('cache', { route: diagnostics.route(context), state: 'custom-handler', reason: 'delegated to incremental cache handler' });
     return require('./incremental-cache.cjs').cachedIncrementalValue(key, producer, { ...options, context, tags, paths, revalidate });
   }
   const target = endpoint();
   // Builds and standalone runtime use have no native cache server. Compute
   // without claiming persistence; production workers always receive its URL.
-  if (!target) return uncachedValue(producer, state, signal);
+  if (!target) {
+    if (diagnostics.enabled) diagnostics.record('cache', { route: diagnostics.route(context), state: 'bypass', reason: 'native cache endpoint unavailable' });
+    return uncachedValue(producer, state, signal);
+  }
   const deadline = Date.now() + WAIT_TIMEOUT_MS;
   while (true) {
     throwIfAborted(signal);
@@ -328,6 +333,8 @@ async function cachedValue(key, producer, options = {}) {
     }
     if (options.versioned && (typeof entry.key !== 'string' || !/^[a-f\d]{64}$/.test(entry.key) || !Number.isSafeInteger(entry.generation) || entry.generation < 0)) throw new Error('Invalid PRNext versioned cache response');
     const entryKey = options.versioned ? entry.key : key;
+    if (diagnostics.enabled && entry.state !== 'pending') diagnostics.record('cache', { route: diagnostics.route(context), state: entry.state,
+      key: key.slice(0, 12), tags: tags.map(diagnostics.label), paths: paths.map(diagnostics.label) });
     const produce = options.versioned ? info => producer({ ...info, generation: entry.generation }) : producer;
     if (entry.state === 'fresh') return decodeValue(entry.value);
     if (entry.state === 'stale') {
@@ -364,6 +371,8 @@ function queueInvalidation(context, operation) {
     if (target) await rpc(target, { op: 'invalidate', ...operation });
     if (custom) await require('./cache-handlers.cjs').invalidateHandlers(context, operation);
     if (incremental) await require('./incremental-cache.cjs').invalidate(context, operation);
+    if (diagnostics.enabled) diagnostics.record('invalidation', { route: diagnostics.route(context), mode: operation.mode,
+      tags: (operation.tags || []).map(diagnostics.label), paths: (operation.paths || []).map(diagnostics.label) });
   });
   // Public invalidation functions return void. Retain errors for the next read
   // or runtime flush without producing an unhandled rejection in the meantime.

package/compat/diagnostics.cjs

@@ -0,0 +1,40 @@
+'use strict';
+// Opt-in, bounded diagnostics. Never retain request headers, cookies or bodies.
+const directory = process.env.PRNEXT_INSPECT_DIR;
+const { threadId } = require('node:worker_threads');
+let queue = [], scheduled = false, writing = false, size;
+const limit = 1024 * 1024;
+function record(type, fields = {}) {
+  if (!directory || queue.length >= 256) return;
+  const line = JSON.stringify({ time: Date.now(), pid: process.pid, type, ...fields }) + '\n';
+  if (Buffer.byteLength(line) > 4096) return;
+  queue.push(line);
+  if (!scheduled) { scheduled = true; setTimeout(flush, 100).unref(); }
+}
+async function flush() {
+  scheduled = false;
+  if (writing || !queue.length) return;
+  writing = true;
+  const fs = require('node:fs/promises'), path = require('node:path');
+  const file = path.join(directory, `worker-${process.pid}-${threadId}.jsonl`);
+  const batch = queue.join(''); queue = [];
+  try {
+    await fs.mkdir(directory, { recursive: true });
+    if (size === undefined) {
+      size = await fs.stat(file).then(value => value.size, () => 0);
+      // Retain the most recent worker sessions. Each has at most two 1 MiB files.
+      const files = await Promise.all((await fs.readdir(directory)).filter(name => /^worker-\d+-\d+\.jsonl(?:\.1)?$/.test(name)).map(async name => ({ name, modified: await fs.stat(path.join(directory, name)).then(value => value.mtimeMs, () => 0) })));
+      for (const old of files.sort((a, b) => b.modified - a.modified).slice(62)) await fs.rm(path.join(directory, old.name), { force: true }).catch(() => {});
+    }
+    if (size + Buffer.byteLength(batch) > limit) { await fs.rm(file + '.1', { force: true }); await fs.rename(file, file + '.1').catch(error => { if (error.code !== 'ENOENT') throw error; }); size = 0; }
+    await fs.appendFile(file, batch, { mode: 0o600 }); size += Buffer.byteLength(batch);
+  } catch { /* Diagnostics must never fail an application request. */ }
+  finally { writing = false; if (queue.length && !scheduled) { scheduled = true; setTimeout(flush, 100).unref(); } }
+}
+function route(context) { return String(context?.routePattern || '<unattributed>').slice(0, 256); }
+function destination(input) {
+  try { const url = new URL(typeof input === 'string' || input instanceof URL ? input : input.url); return (url.origin + url.pathname).slice(0, 256); }
+  catch { return '<unknown>'; }
+}
+function label(value) { return require('node:crypto').createHash('sha256').update(String(value)).digest('hex').slice(0, 12); }
+module.exports = { enabled: Boolean(directory), record, route, destination, label, flush };

package/compat/static-generation.cjs

@@ -1,5 +1,6 @@
 'use strict';
 const {sampleObject} = require('./instant-samples.cjs');
+const diagnostics = require('./diagnostics.cjs');
 let requestReader;
 
 function context() {
@@ -24,6 +25,7 @@ function dynamicUsage(reason, request = context()) {
 }
 
 function staticBailout(reason, request = context()) {
+  if (diagnostics.enabled) diagnostics.record('dynamic', { route: diagnostics.route(request), reason });
   const state = request?.staticState;
   if (!state) return true;
   if (state.partial && state.mode === 'auto') {

package/native/npm.mjs

@@ -0,0 +1,29 @@
+import { existsSync, realpathSync } from 'node:fs';
+import path from 'node:path';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+
+const execute = promisify(execFile);
+
+// Execute npm's JS entry point: .cmd shims cannot be execFile'd on Windows.
+// No shell interpolation, including when the project path contains spaces.
+export function npmCommand(env = process.env) {
+  const candidates = [env.npm_execpath];
+  const directories = [path.dirname(process.execPath), ...(env.PATH || env.Path || '').split(path.delimiter)];
+  for (const directory of directories.filter(Boolean)) {
+    candidates.push(path.join(directory, 'node_modules/npm/bin/npm-cli.js'));
+    try {
+      const npm = realpathSync(path.join(directory, process.platform === 'win32' ? 'npm.cmd' : 'npm'));
+      candidates.push(npm.endsWith('.js') ? npm : path.join(path.dirname(npm), 'node_modules/npm/bin/npm-cli.js'));
+    } catch {}
+  }
+  const cli = candidates.find(file => file && /(?:^|[/\\])npm-cli\.js$/.test(file) && existsSync(file));
+  if (cli) return { command: process.execPath, args: [cli] };
+  if (process.platform !== 'win32') return { command: 'npm', args: [] };
+  throw new Error('Cannot locate npm-cli.js. Install Node.js with npm, or run this command through npm run.');
+}
+
+export function executeNpm(args, options = {}) {
+  const npm = npmCommand();
+  return execute(npm.command, [...npm.args, ...args], { windowsHide: true, ...options });
+}

package/native/platforms.json

@@ -2,5 +2,7 @@
   { "id": "darwin-arm64", "package": "prnext-darwin-arm64", "os": "darwin", "cpu": "arm64", "target": "aarch64-apple-darwin" },
   { "id": "darwin-x64", "package": "prnext-darwin-x64", "os": "darwin", "cpu": "x64", "target": "x86_64-apple-darwin" },
   { "id": "linux-arm64-gnu", "package": "prnext-linux-arm64-gnu", "os": "linux", "cpu": "arm64", "libc": "glibc", "target": "aarch64-unknown-linux-gnu" },
-  { "id": "linux-x64-gnu", "package": "prnext-linux-x64-gnu", "os": "linux", "cpu": "x64", "libc": "glibc", "target": "x86_64-unknown-linux-gnu" }
+  { "id": "linux-x64-gnu", "package": "prnext-linux-x64-gnu", "os": "linux", "cpu": "x64", "libc": "glibc", "target": "x86_64-unknown-linux-gnu" },
+  { "id": "win32-x64-msvc", "package": "@thomas.f/prnext-win32-x64-msvc", "os": "win32", "cpu": "x64", "target": "x86_64-pc-windows-msvc" },
+  { "id": "win32-arm64-msvc", "package": "@thomas.f/prnext-win32-arm64-msvc", "os": "win32", "cpu": "arm64", "target": "aarch64-pc-windows-msvc" }
 ]

package/native/resolve.mjs

@@ -8,6 +8,7 @@ import path from 'node:path';
 export const packageRoot = fileURLToPath(new URL('../', import.meta.url));
 export const packageManifest = JSON.parse(readFileSync(path.join(packageRoot, 'package.json'), 'utf8'));
 export const platforms = JSON.parse(readFileSync(new URL('./platforms.json', import.meta.url), 'utf8'));
+export const nativeBinaryName = (platform = process.platform) => platform === 'win32' ? 'prnext.exe' : 'prnext';
 
 // A dependency installed in node_modules must never mistake its consumer for
 // the framework checkout, even if that consumer also has a Cargo workspace.
@@ -27,7 +28,7 @@ export function nativePlatform({ platform = process.platform, arch = process.arc
     libc = process.report?.getReport().header.glibcVersionRuntime ? 'glibc' : 'musl';
   }
   const result = platforms.find(item => item.os === platform && item.cpu === arch && (!item.libc || item.libc === libc));
-  if (!result) throw new Error(`PRNext has no prebuilt server for ${platform}/${arch}${libc ? `/${libc}` : ''}. This alpha provides macOS arm64/x64 and Linux glibc arm64/x64. Use a supported system (WSL on Windows), or set PRNEXT_BINARY to your own compatible build.`);
+  if (!result) throw new Error(`PRNext has no prebuilt server for ${platform}/${arch}${libc ? `/${libc}` : ''}. Supported targets are Windows (MSVC), macOS and Linux glibc on arm64/x64. Use a supported system, or set PRNEXT_BINARY to your own compatible build.`);
   return result;
 }
 
@@ -47,7 +48,7 @@ export async function resolveNativeBinary({ env = process.env, root = packageRoo
   }
   const checkout = sourceCheckout(root);
   if (checkout) {
-    const binary = path.join(checkout, 'target/release', process.platform === 'win32' ? 'prnext.exe' : 'prnext');
+    const binary = path.join(checkout, 'target/release', nativeBinaryName());
     try { return await executableFile(binary); }
     catch (error) { if (error.code !== 'ENOENT') throw error; }
     if (!allowBuild) throw new Error('Native server missing from this checkout. Run npm run build:native.');
@@ -75,7 +76,7 @@ export async function resolveNativeBinary({ env = process.env, root = packageRoo
   if (native.name !== target.package || native.version !== manifest.version) {
     throw new Error(`PRNext native version mismatch: expected ${target.package}@${manifest.version}, found ${native.name}@${native.version}. Reinstall matching versions.`);
   }
-  const binary = path.join(path.dirname(nativeManifestFile), 'bin', 'prnext');
+  const binary = path.join(path.dirname(nativeManifestFile), 'bin', nativeBinaryName(target.os));
   try { return await executableFile(binary); }
   catch (cause) { throw new Error(`PRNext native executable is missing or not executable in ${target.package}. Reinstall the package.`, { cause }); }
 }

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@thomas.f/prnext",
-  "version": "0.1.0-alpha.1",
+  "version": "0.1.11-alpha",
+  "license": "MIT",
   "description": "Experimental Rust-powered runtime for Next.js apps, React and npm",
   "homepage": "https://prnext.dev",
   "repository": {
@@ -116,10 +117,12 @@
     "react-server-dom-webpack": "19.3.0"
   },
   "optionalDependencies": {
-    "prnext-darwin-arm64": "0.1.0-alpha.1",
-    "prnext-darwin-x64": "0.1.0-alpha.1",
-    "prnext-linux-arm64-gnu": "0.1.0-alpha.1",
-    "prnext-linux-x64-gnu": "0.1.0-alpha.1"
+    "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"
   },
   "engines": {
     "node": ">=22"

package/release/verify.mjs

@@ -6,7 +6,7 @@ import { packageRoot, packageManifest, platforms, sourceCheckout } from '../nati
 export async function verifyPackage() {
   const pkg = packageManifest;
   if (pkg.private === true) throw new Error(`${pkg.name} is marked private.`);
-  if (!/^\d+\.\d+\.\d+-alpha\.\d+$/.test(pkg.version)) throw new Error('This release workflow requires an explicit x.y.z-alpha.N version.');
+  if (!/^\d+\.\d+\.\d+-alpha(?:\.\d+)?$/.test(pkg.version)) throw new Error('This release workflow requires an explicit x.y.z-alpha or x.y.z-alpha.N version.');
   if (pkg.publishConfig?.tag !== 'alpha' || pkg.publishConfig?.access !== 'public') throw new Error('Alpha releases require publishConfig.tag=alpha and access=public.');
   if (pkg.bin?.prn !== './cli.mjs' || pkg.bin?.prnext !== './cli.mjs') throw new Error('Both prn and prnext must point to cli.mjs.');
   const expected = Object.fromEntries(platforms.map(item => [item.package, pkg.version]));
@@ -35,7 +35,7 @@ export async function verifyPublishedNatives({ registry = 'https://registry.npmj
   const problems = [];
   for (const target of platforms) {
     try {
-      const url = new URL(`${target.package}/${packageManifest.version}`, registry);
+      const url = new URL(`${encodeURIComponent(target.package)}/${encodeURIComponent(packageManifest.version)}`, registry);
       const response = await fetcher(url, { signal: AbortSignal.timeout(15_000) });
       if (!response.ok) throw new Error(`registry returned HTTP ${response.status}`);
       const pkg = await response.json();