@thomas.f/prnext 0.1.0-alpha.1

package/build/scan.mjs

@@ -0,0 +1,178 @@
+import { access } from 'node:fs/promises';
+import {readDirectory} from './directory-cache.mjs';
+import path from 'node:path';
+import { createHash } from 'node:crypto';
+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';
+
+const sourceExtension = /\.(?:[cm]?js|jsx|tsx?)$/;
+
+async function exists(file) {
+  try { await access(file); return true; } catch { return false; }
+}
+
+async function walk(directory) {
+  const files = [];
+  for (const item of await readDirectory(directory)) {
+    if (item.name.startsWith('.')) continue;
+    const file = path.join(directory, item.name);
+    if (item.isDirectory()) files.push(...await walk(file));
+    else if (item.isFile()) files.push(file);
+  }
+  return files.sort();
+}
+
+export function routePattern(relativeFile, extensionPattern = sourceExtension) {
+  const segments = relativeFile.replaceAll(path.sep, '/').replace(extensionPattern, '').split('/');
+  if (segments.at(-1) === 'index') segments.pop();
+  return validatePattern(segments, relativeFile);
+}
+
+function validatePattern(segments, relativeFile) {
+  const names = new Set();
+  for (const [index, segment] of segments.entries()) {
+    if (!segment.includes('[') && !segment.includes(']')) continue;
+    const match = /^(?:\[([A-Za-z_$][\w$]*)\]|\[\.\.\.([A-Za-z_$][\w$]*)\]|\[\[\.\.\.([A-Za-z_$][\w$]*)\]\])$/.exec(segment);
+    if (!match) throw new Error(`Unsupported route segment "${segment}" in ${relativeFile}. Use [id], [...slug], or [[...slug]].`);
+    const name = match[1] || match[2] || match[3];
+    if (names.has(name)) throw new Error(`Duplicate parameter "${name}" in ${relativeFile}.`);
+    names.add(name);
+    if ((match[2] || match[3]) && index !== segments.length - 1) {
+      throw new Error(`Catch-all parameter must be the final segment in ${relativeFile}.`);
+    }
+  }
+  const pattern = '/' + segments.join('/');
+  if (pattern === '/_prnext' || pattern.startsWith('/_prnext/')) {
+    throw new Error(`Route ${pattern} uses the reserved /_prnext namespace.`);
+  }
+  return pattern;
+}
+
+export async function scanProject(projectRoot, { basePath = '', pageExtensions, i18n } = {}) {
+  const sourceExtension = pageExtensionPattern(pageExtensions);
+  const root = path.resolve(projectRoot);
+  const middleware = await scanMiddleware(root, { basePath, pageExtensions, i18n });
+  const roots = [];
+  for (const name of ['pages', 'src/pages']) if (await exists(path.join(root, name))) roots.push(path.join(root, name));
+  if (roots.length > 1) throw new Error('Both pages/ and src/pages/ exist. Keep exactly one Pages Router directory.');
+  const appRoots = [];
+  for (const name of ['app', 'src/app']) if (await exists(path.join(root, name))) appRoots.push(path.join(root, name));
+  if (appRoots.length > 1) throw new Error('Both app/ and src/app/ exist. Keep exactly one App Router directory.');
+  if (!roots.length && !appRoots.length) throw new Error('No pages/, src/pages/, app/, or src/app/ directory found. Create app/page.tsx or pages/index.tsx to start.');
+  const pageRoot = roots[0];
+  const files = (pageRoot ? await walk(pageRoot) : []).filter(file => sourceExtension.test(file) && !file.endsWith('.d.ts'));
+  const routes = [];
+  const patterns = new Map();
+  const pagesErrors = {};
+  let app;
+  let document;
+  for (const file of files) {
+    validatePageSource(file);
+    const relative = path.relative(pageRoot, file).replaceAll(path.sep, '/');
+    const name = relative.replace(sourceExtension, '');
+    if (name === '_app') {
+      if (app) throw new Error('Multiple _app files found. Keep only one.');
+      app = file;
+      continue;
+    }
+    if (name === '_document') {
+      if (document) throw new Error('Multiple _document files found. Keep only one.');
+      document = file;
+      continue;
+    }
+    const pattern = routePattern(relative, sourceExtension);
+    const signature = pattern.replace(/\[\[\.\.\.[^\]]+\]\]/g, '[[...]]').replace(/\[\.\.\.[^\]]+\]/g, '[...]').replace(/\[[^\]]+\]/g, '[]');
+    if (patterns.has(signature)) throw new Error(`Conflicting routes: ${patterns.get(signature)} and ${relative} both match ${pattern}.`);
+    patterns.set(signature, relative);
+    const kind = relative.startsWith('api/') ? 'api' : 'page';
+    const id = `${kind}-${createHash('sha256').update(pattern).digest('hex').slice(0, 12)}`;
+    const errorKind = name === '_error' ? 'error' : pattern === '/404' ? 'notFound' : pattern === '/500' ? 'serverError' : undefined;
+    if (errorKind) pagesErrors[errorKind] = id;
+    routes.push({ id, pattern, kind, file,
+      ...(errorKind === 'error' ? { internal: true } : errorKind ? { errorStatus: pattern === '/404' ? 404 : 500 } : {}),
+    });
+  }
+  const appRoot = appRoots[0];
+  const { appNotFound, appGlobalError } = appRoot ? await scanAppRoutes({ root, appRoot, routes, patterns, sourceExtension }) : {};
+  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.');
+  return { root, pageRoot, appRoot, app, document, routes, ...(appNotFound ? { appNotFound } : {}), ...(appGlobalError ? { appGlobalError } : {}), ...(Object.keys(pagesErrors).length ? { pagesErrors } : {}), ...(middleware ? { middleware } : {}) };
+}
+
+const appConventions = new Map([
+  ['page', 'page'], ['route', 'route'], ['layout', 'layout'], ['template', 'template'],
+  ['loading', 'loading'], ['error', 'error'], ['not-found', 'notFound'], ['default', 'default'],
+]);
+
+async function scanAppRoutes({ root, appRoot, routes, patterns, sourceExtension }) {
+  const directories = new Map();
+  const configs = new Map();
+  let appGlobalError;
+  for (const file of await walk(appRoot)) {
+    if (!sourceExtension.test(file) || file.endsWith('.d.ts')) continue;
+    const relative = path.relative(appRoot, file).replaceAll(path.sep, '/');
+    const parts = relative.split('/');
+    const filename = parts.pop().replace(sourceExtension, '');
+    if (parts.some(segment => segment.startsWith('_'))) continue;
+    if (filename === 'global-error') {
+      // 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.');
+        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.`);
+    descriptor.files[name] = file;
+    directories.set(directory, descriptor);
+  }
+  const advanced = [...directories.keys()].some(directory => directory.split('/').some(segment => segment.startsWith('@') || /^\(\.{1,3}\)/.test(segment)));
+  if (advanced) scanAdvancedAppRoutes({ root, appRoot, directories, configs, routes, patterns, validatePattern });
+  for (const { directory, files } of advanced ? [] : directories.values()) {
+    if (!files.page && !files.route) continue;
+    if (files.page && files.route) throw new Error(`Conflicting routes: App Router page and route handler both occupy ${directory || '/'}.`);
+    const parts = directory ? directory.split('/') : [];
+    const urlParts = parts.filter(segment => !/^\([^()]+\)$/.test(segment)).map(segment => segment.replace(/^%5f/i, '_'));
+    const pattern = validatePattern(urlParts, path.relative(root, files.page || files.route));
+    const signature = pattern.replace(/\[\[\.\.\.[^\]]+\]\]/g, '[[...]]').replace(/\[\.\.\.[^\]]+\]/g, '[...]').replace(/\[[^\]]+\]/g, '[]');
+    const label = path.relative(root, files.page || files.route);
+    if (patterns.has(signature)) throw new Error(`Conflicting routes: ${patterns.get(signature)} and ${label} both match ${pattern} (App Router).`);
+    patterns.set(signature, label);
+    const kind = files.page ? 'page' : 'api';
+    const id = `app-${kind}-${createHash('sha256').update(pattern).digest('hex').slice(0, 12)}`;
+    const segments = [];
+    for (let index = 0; index <= parts.length; index++) {
+      const directory = parts.slice(0, index).join('/');
+      const descriptor = directories.get(directory);
+      const { page, route, ...conventions } = descriptor?.files || {};
+      segments.push({ segment: index ? parts[index - 1] : '', path: directory, ...conventions,
+        ...(conventions.layout ? { staticConfig: configs.get(conventions.layout) || {} } : {}),
+      });
+    }
+    if (kind === 'page' && !segments.some(segment => segment.layout)) throw new Error(`App Router page ${label} needs a root layout. Create app/layout.tsx with <html> and <body>.`);
+    const configFiles = kind === 'page' ? [...segments.map(segment => segment.layout).filter(Boolean), files.page] : [files.route];
+    const cacheConfig = mergeAppConfig(configFiles.map(file => configs.get(file) || {}));
+    routes.push({ id, pattern, kind, router: 'app', file: files.page || files.route, cacheConfig,
+      ...(kind === 'page' ? { segments, pageConfig: configs.get(files.page) || {} } : { handlerConfig: configs.get(files.route) || {} }),
+    });
+  }
+  const rootDescriptor = directories.get('');
+  if (rootDescriptor?.files.layout) {
+    if (routes.some(route => route.pattern === '/_not-found')) throw new Error('/_not-found is reserved for the App Router not-found entry.');
+    const { page, route, ...conventions } = rootDescriptor.files;
+    return { appGlobalError, appNotFound: { segments: [{ segment: '', path: '', ...conventions, staticConfig: configs.get(conventions.layout) || {} }],
+      cacheConfig: mergeAppConfig([configs.get(conventions.layout) || {}]), pageConfig: {} } };
+  }
+  return { appGlobalError };
+}

package/build/script-workers.mjs

@@ -0,0 +1,25 @@
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+/** Partytown is supplied by the application, just like Next's experimental integration. */
+export async function prepareScriptWorkers({ projectRoot, stage, assetBase }) {
+  const resolve = createRequire(path.join(projectRoot, 'package.json'));
+  let integrationPath, utilitiesPath;
+  try {
+    integrationPath = resolve.resolve('@builder.io/partytown/integration');
+    utilitiesPath = resolve.resolve('@builder.io/partytown/utils');
+  } catch (cause) {
+    throw new Error('experimental.nextScriptWorkers requires @builder.io/partytown in the application. Install it with npm install --save-dev @builder.io/partytown, or disable this flag.', { cause });
+  }
+  const [integration, utilities] = await Promise.all([import(pathToFileURL(integrationPath).href), import(pathToFileURL(utilitiesPath).href)]);
+  const partytownSnippet = (integration.default || integration).partytownSnippet;
+  const copyLibFiles = (utilities.default || utilities).copyLibFiles;
+  if (typeof partytownSnippet !== 'function' || typeof copyLibFiles !== 'function') {
+    throw new Error('The installed @builder.io/partytown must export integration.partytownSnippet and utils.copyLibFiles.');
+  }
+  const snippet = partytownSnippet();
+  if (typeof snippet !== 'string' || !snippet) throw new Error('@builder.io/partytown returned an invalid bootstrap snippet.');
+  await copyLibFiles(path.join(stage, 'assets', '~partytown'));
+  return { lib: assetBase + '/~partytown/', snippet };
+}

package/build/server-actions-config.mjs

@@ -0,0 +1,27 @@
+export function validateServerActions(input) {
+  if (input === undefined || input === true) input = {};
+  if (!input || typeof input !== 'object' || Array.isArray(input)) throw new TypeError('experimental.serverActions must be an object');
+  for (const name of Object.keys(input)) if (!['allowedOrigins', 'bodySizeLimit'].includes(name)) throw new TypeError(`experimental.serverActions.${name} is not implemented`);
+  const origins = input.allowedOrigins ?? [];
+  if (!Array.isArray(origins) || origins.length > 128) throw new TypeError('serverActions.allowedOrigins must contain at most 128 host patterns');
+  for (const origin of origins) {
+    if (typeof origin !== 'string' || !origin || origin.length > 256 || /[^\x21-\x7e]|[/\\@?#]/.test(origin)) throw new TypeError('serverActions.allowedOrigins expects host names with optional ports, not URLs');
+    if (origin.startsWith('[')) {
+      try { const url = new URL('http://' + origin); if (url.host !== origin.toLowerCase() && url.port !== '') throw new Error(); }
+      catch { throw new TypeError(`Invalid serverActions.allowedOrigins host: ${origin}`); }
+    } else {
+      const match = /^([^:]+)(?::([0-9]+))?$/.exec(origin);
+      if (!match || match[2] && (Number(match[2]) > 65535 || Number(match[2]) < 1)) throw new TypeError(`Invalid serverActions.allowedOrigins host: ${origin}`);
+      const labels = match[1].split('.');
+      if (labels.some((part, index) => !/^[a-zA-Z0-9_-]+$/.test(part) && part !== '*' && !(part === '**' && index === 0)) || labels.length === 1 && labels[0].includes('*')) throw new TypeError(`Invalid serverActions.allowedOrigins pattern: ${origin}`);
+    }
+  }
+  let bytes = input.bodySizeLimit ?? 1024 * 1024;
+  if (typeof bytes === 'string') {
+    const match = /^(\d+(?:\.\d+)?)\s*(b|kb|mb|gb|tb|pb)?$/i.exec(bytes.trim());
+    if (!match) throw new TypeError('serverActions.bodySizeLimit expects bytes or a size such as "2mb"');
+    bytes = Math.floor(Number(match[1]) * 1024 ** Math.max(0, ['b', 'kb', 'mb', 'gb', 'tb', 'pb'].indexOf((match[2] || 'b').toLowerCase())));
+  }
+  if (!Number.isSafeInteger(bytes) || bytes < 1 || bytes > 8 * 1024 * 1024) throw new TypeError('serverActions.bodySizeLimit must be between 1 byte and the 8 MiB request transport limit');
+  return { allowedOrigins: [...new Set(origins.map(origin => origin.toLowerCase()))], bodySizeLimit: bytes };
+}

package/build/source-maps.mjs

@@ -0,0 +1,34 @@
+import {AsyncLocalStorage} from 'node:async_hooks';
+const scope = new AsyncLocalStorage();
+export const withSourceMaps = callback => scope.run({enabled:false},callback);
+export const configureSourceMaps = enabled => {if(scope.getStore())scope.getStore().enabled=!!enabled;};
+export const sourceMapsEnabled = () => scope.getStore()?.enabled === true;
+const directive = /(?:\/\/[#@]\s*sourceMappingURL=([^\s]+)|\/\*[#@]\s*sourceMappingURL=([^*]+)\*\/)/g;
+
+export function extractSourceMap(source) {
+  let map;
+  const code=source.replace(directive,(comment,line,block)=>{
+    const url=(line || block).trim();
+    if(!url.startsWith('data:application/json'))return comment;
+    const comma=url.indexOf(',');
+    try {map=JSON.parse(url.slice(0,comma).includes(';base64')?Buffer.from(url.slice(comma+1),'base64').toString():decodeURIComponent(url.slice(comma+1)));}
+    catch {throw new Error('Invalid inline source map');}
+    // Keep original line coordinates while discarding the stale directive.
+    return line ? '' : comment.replace(/[^\r\n]/g,' ');
+  });
+  return {code,map};
+}
+export function inlineSourceMap(source,map) {
+  if(!map)return source;
+  const clean=extractSourceMap(source).code;
+  return clean+'\n//# sourceMappingURL=data:application/json;base64,'+Buffer.from(JSON.stringify(typeof map==='string'?JSON.parse(map):map)).toString('base64');
+}
+
+/** Babel composes the new locations directly with the previous transform map. */
+export function generateMapped(generate,ast,options,source,file) {
+  if(!sourceMapsEnabled())return generate(ast,options,source).code;
+  const {code,map}=extractSourceMap(source);
+  const result=generate(ast,{...options,sourceMaps:true,sourceFileName:file,inputSourceMap:map,
+    shouldPrintComment:comment=>!/[#@]\s*sourceMappingURL=/.test(comment)},code);
+  return inlineSourceMap(result.code,result.map);
+}

package/build/standalone-config.mjs

@@ -0,0 +1,19 @@
+import path from 'node:path';
+
+export function validateStandaloneConfig(config) {
+  if (config.output !== undefined && !['standalone', 'export'].includes(config.output)) throw new Error('output supports "standalone" or "export".');
+  if (config.outputFileTracingRoot !== undefined && (typeof config.outputFileTracingRoot !== 'string' || !path.isAbsolute(config.outputFileTracingRoot) || config.outputFileTracingRoot.includes('\0') || config.outputFileTracingRoot.length > 4096)) throw new Error('outputFileTracingRoot must be an absolute directory path.');
+  for (const key of ['outputFileTracingIncludes', 'outputFileTracingExcludes']) {
+    const rules = config[key];
+    if (rules === undefined) continue;
+    if (!rules || typeof rules !== 'object' || Array.isArray(rules) || Object.keys(rules).length > 256) throw new Error(`${key} must map at most 256 route globs to arrays of file globs.`);
+    let count = 0;
+    for (const [route, patterns] of Object.entries(rules)) {
+      if (!route.startsWith('/') || route.length > 4096 || route.includes('\0') || !Array.isArray(patterns)) throw new Error(`${key} must map URL route globs to arrays of relative file globs.`);
+      for (const pattern of patterns) {
+        if (typeof pattern !== 'string' || !pattern || pattern.length > 4096 || path.isAbsolute(pattern) || /[\0\\]/.test(pattern) || pattern.startsWith('!') || ++count > 1024) throw new Error(`${key} file globs must be relative paths; at most 1024 patterns are supported.`);
+      }
+    }
+  }
+  return config;
+}

package/build/standalone-runner.mjs

@@ -0,0 +1,21 @@
+import { Worker } from 'node:worker_threads';
+
+// Prerender installs Flight's webpack shims. NFT's native-loader discovery must
+// see ordinary Node globals, so tracing runs in its own short-lived isolate.
+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')),
+  });
+  try {
+    await new Promise((resolve, reject) => {
+      worker.once('message', message => {
+        if (message.ok) resolve();
+        else { const error = new Error(message.error?.message || 'Standalone preparation failed'); if (message.error?.stack) error.stack = message.error.stack; reject(error); }
+      });
+      worker.once('error', reject);
+      worker.once('exit', code => reject(new Error(`Standalone preparation exited before completion (${code})`)));
+    });
+  } finally { await worker.terminate(); }
+}

package/build/standalone-worker.mjs

@@ -0,0 +1,5 @@
+import { parentPort, workerData } from 'node:worker_threads';
+import { createStandalone } from './standalone.mjs';
+
+try { await createStandalone(workerData); parentPort.postMessage({ ok: true }); }
+catch (error) { parentPort.postMessage({ error: { message: error.message, stack: error.stack } }); }

package/build/standalone.mjs

@@ -0,0 +1,240 @@
+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 path from 'node:path';
+import { resolveNativeBinary } from '../native/resolve.mjs';
+import { createHash } from 'node:crypto';
+import { createRequire } from 'node:module';
+
+const slash = value => value.split(path.sep).join('/');
+const within = (root, file) => file === root || file.startsWith(root + path.sep);
+const missing = error => error.code === 'ENOENT' || error.code === 'ENOTDIR';
+const maxFiles = 100_000;
+const maxBytes = 2 * 1024 ** 3;
+
+function patternsFor(rules, route) {
+  return Object.entries(rules || {}).flatMap(([key, values]) => picomatch(key, { dot: true })(route) ? values : []);
+}
+
+async function* walk(directory) {
+  const entries = await readdir(directory, { withFileTypes: true });
+  for (const entry of entries) {
+    const file = path.join(directory, entry.name);
+    if (entry.isDirectory()) yield* walk(file);
+    else yield file;
+  }
+}
+
+// Resolve each configured pattern from its literal prefix, not by traversing a
+// monorepo's entire dependency tree. Symlink directories are handled by NFT.
+async function includedFiles(root, tracingRoot, patterns) {
+  const output = new Set();
+  for (const pattern of patterns) {
+    const absolute = path.resolve(root, pattern);
+    const parts = absolute.split(path.sep);
+    const wildcard = parts.findIndex(part => /[*?{[(!+@]/.test(part));
+    const prefix = wildcard < 0 ? absolute : parts.slice(0, wildcard).join(path.sep) || path.parse(root).root;
+    if (!within(tracingRoot, prefix)) throw new Error(`Tracing include ${pattern} leaves outputFileTracingRoot.`);
+    let info;
+    try { info = await stat(prefix); } catch (error) { if (missing(error)) continue; throw error; }
+    const match = picomatch(slash(absolute), { dot: true });
+    if (info.isDirectory()) {
+      let scanned = 0;
+      for await (const file of walk(prefix)) {
+        if (++scanned > maxFiles) throw new Error('Standalone include traverses more than 100000 files. Narrow its glob.');
+        if (match(slash(file))) output.add(file);
+      }
+    } else if (match(slash(prefix))) output.add(prefix);
+  }
+  return output;
+}
+
+export async function createStandalone({ projectRoot, stage, manifest, config }) {
+  if (config.output !== 'standalone' || manifest.dev) return;
+  projectRoot = await realpath(projectRoot);
+  stage = await realpath(stage);
+  const tracingRoot = await realpath(config.outputFileTracingRoot || projectRoot);
+  if (!within(tracingRoot, projectRoot)) throw new Error('outputFileTracingRoot must contain the application directory.');
+  const appRelative = path.relative(tracingRoot, projectRoot);
+  const output = path.join(stage, 'standalone');
+  const appOutput = path.join(output, 'app', appRelative);
+  const traceFiles = new Set();
+  const manualFiles = new Set();
+  const bridges = new Map();
+  const packageRoots = new Map();
+  const warnings = new Set();
+  let omittedWarnings = 0;
+  const cache = {};
+  let traceReads = 0;
+  let traceBytes = 0;
+
+  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));
+    const offset = file.indexOf(`${path.sep}node_modules${path.sep}`);
+    if (offset >= 0) {
+      const anchor = file.slice(0, offset);
+      const key = createHash('sha256').update(anchor).digest('hex').slice(0, 16);
+      return path.join(output, 'dependencies', key, file.slice(offset + 1));
+    }
+    throw new Error(`Standalone trace ${file} is outside outputFileTracingRoot. Set that option to the shared workspace root.`);
+  }
+
+  async function packageRoot(filename, name) {
+    const key = filename + '\0' + name;
+    if (!packageRoots.has(key)) packageRoots.set(key, (async () => {
+      for (let dir = path.dirname(filename); dir !== path.dirname(dir); dir = path.dirname(dir)) {
+        try {
+          const metadata = JSON.parse(await readFile(path.join(dir, 'package.json'), 'utf8'));
+          if (metadata.name === name || dir.endsWith(path.sep + 'node_modules' + path.sep + name.split('/').join(path.sep))) return dir;
+        }
+        catch (error) { if (!missing(error) && !(error instanceof SyntaxError)) throw error; }
+      }
+    })());
+    return packageRoots.get(key);
+  }
+
+  async function trace(entries, route) {
+    const excluded = patternsFor(config.outputFileTracingExcludes, route).map(value => picomatch(slash(path.resolve(projectRoot, value)), { dot: true }));
+    for (const conditions of [['node'], ['node', 'react-server']]) {
+      const result = await nodeFileTrace(entries, {
+        base: path.parse(projectRoot).root, processCwd: projectRoot, conditions, cache, fileIOConcurrency: 16,
+        ignore(file) { const absolute = path.resolve(path.parse(projectRoot).root, file); return !within(stage, absolute) && (excluded.some(match => match(slash(absolute))) || /^\.env(?:\.|$)/.test(path.basename(absolute))); },
+        async readFile(file) {
+          let info;
+          try { info = await stat(file); } catch (error) { if (missing(error)) return null; throw error; }
+          if (!info.isFile()) return null;
+          if (++traceReads > maxFiles || info.size > 32 * 1024 ** 2 || (traceBytes += info.size) > 512 * 1024 ** 2) throw new Error('Standalone tracing exceeded its 100000 reads / 32 MiB file / 512 MiB source budget. Narrow tracing inputs.');
+          return readFile(file);
+        },
+        async resolve(specifier, parent, job, cjs) {
+          const resolved = await resolver.default(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);
+            }
+          }
+          return resolved;
+        },
+      });
+      for (const file of result.fileList) traceFiles.add(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;
+        if (warnings.size < 128) warnings.add(message); else omittedWarnings++;
+      }
+      if (traceFiles.size > maxFiles) throw new Error('Standalone trace exceeds 100000 files.');
+    }
+    for (const file of await includedFiles(projectRoot, tracingRoot, patternsFor(config.outputFileTracingIncludes, route))) if (!excluded.some(match => match(slash(file)))) { traceFiles.add(file); manualFiles.add(file); }
+  }
+
+  // Runtime imports are lazy and routes/client references are selected from the
+  // manifest. Give NFT all these roots explicitly, including both React modes.
+  const names = new Set(['worker', 'http']);
+  if (manifest.routes.some(route => route.router !== 'app' && route.kind === 'page')) names.add('render');
+  if (manifest.routes.some(route => route.kind === 'api')) { names.add('api'); names.add('route-static'); }
+  if (manifest.routes.some(route => route.router === 'app' && route.kind === 'page')) for (const name of ['app-render', 'app-static', 'rsc-worker']) names.add(name);
+  if (manifest.middleware) names.add('middleware');
+  if (manifest.config.cacheHandler) names.add('incremental-cache');
+  const runtimeRoots = [...names].map(name => path.join(stage, 'runtime', name + '.mjs'));
+  if (names.has('app-render')) {
+    // flightDecoder selects the production/development CJS decoder at runtime
+    // after require.resolve(). NFT cannot infer that computed filename.
+    const require = createRequire(path.join(stage, 'runtime/app-render.mjs'));
+    runtimeRoots.push(require.resolve('react-server-dom-webpack/client.node'));
+  }
+  await trace(runtimeRoots, '/*');
+  const groups = new Map();
+  for (const route of manifest.routes) {
+    const key = JSON.stringify([patternsFor(config.outputFileTracingIncludes, route.pattern), patternsFor(config.outputFileTracingExcludes, route.pattern)]);
+    if (!groups.has(key)) groups.set(key, { entries: [], pattern: route.pattern });
+    groups.get(key).entries.push(path.join(stage, route.module));
+  }
+  for (const { entries, pattern } of groups.values()) await trace(entries, pattern);
+  const dynamicRoots = [...Object.values(manifest.app?.clientModules || {}).map(value => value.ssrModule),
+    ...Object.values(manifest.app?.actions || {}).map(value => value.module),
+    manifest.middleware?.module, manifest.config.cacheHandler, ...Object.values(manifest.config.cacheHandlers || {})]
+    .filter(Boolean).map(file => path.join(stage, file));
+  if (dynamicRoots.length) await trace(dynamicRoots, '/*');
+
+  // Copy immutable build assets and public files regardless of trace exclusions.
+  // Exclusions tune dependencies, never silently remove the server itself.
+  for await (const file of walk(stage)) traceFiles.add(file);
+  try { for await (const file of walk(path.join(projectRoot, 'public'))) { traceFiles.add(file); manualFiles.add(file); } }
+  catch (error) { if (!missing(error)) throw error; }
+  // Materialize symlink targets, including explicit includes/public directories
+  // which did not go through NFT. All output links point within the artifact.
+  for (const source of manualFiles) {
+    if (!(await lstat(source)).isSymbolicLink()) continue;
+    const target = await realpath(source);
+    relocated(target);
+    if ((await stat(target)).isDirectory()) {
+      for await (const file of walk(target)) {
+        traceFiles.add(file);
+        manualFiles.add(file);
+        if (traceFiles.size > maxFiles) throw new Error('Standalone trace exceeds 100000 files.');
+      }
+    } else traceFiles.add(target);
+  }
+  await mkdir(output, { recursive: true });
+  let copiedBytes = 0;
+  let copiedFiles = 0;
+  const pendingLinks = [];
+  for (const source of traceFiles) {
+    const target = relocated(source);
+    const info = await lstat(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);
+      pendingLinks.push([target, relocated(destination)]);
+      continue;
+    }
+    if (!info.isFile()) continue;
+    await mkdir(path.dirname(target), { recursive: true });
+    await copyFile(source, target);
+  }
+  const owners = new Set(bridges.values());
+  const includedOwners = new Set();
+  for (const file of traceFiles) for (let dir = path.dirname(file); dir !== path.dirname(dir); dir = path.dirname(dir)) if (owners.has(dir)) includedOwners.add(dir);
+  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)]);
+  }
+  for (const [link, target] of pendingLinks) {
+    if (link === target) continue;
+    await mkdir(path.dirname(link), { recursive: true });
+    try {
+      const current = await lstat(link);
+      if (current.isDirectory()) continue;
+      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');
+  }
+  const binaryName = process.platform === 'win32' ? 'prnext.exe' : 'prnext';
+  const binary = await resolveNativeBinary();
+  await mkdir(path.join(output, 'bin'), { recursive: true });
+  await copyFile(binary, path.join(output, 'bin', binaryName));
+  await chmod(path.join(output, 'bin', binaryName), 0o755);
+  await mkdir(appOutput, { recursive: true });
+  await writeFile(path.join(appOutput, '.prnext-output.json'), JSON.stringify({ distDir: config.distDir }) + '\n');
+  // Preserve package type, imports/exports, self references and application
+  // reads of its package metadata. Package scripts are never executed here.
+  let packageJson = '{"private":true}\n';
+  try { packageJson = await readFile(path.join(projectRoot, 'package.json'), 'utf8'); } catch (error) { if (!missing(error)) throw error; }
+  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`);
+  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`);
+    await chmod(path.join(output, 'start'), 0o755);
+  }
+  await writeFile(path.join(output, 'standalone.json'), JSON.stringify({ version: 1, app: relativeApp, distDir: config.distDir, platform: process.platform, arch: process.arch, node: process.versions.node, nodeModulesABI: process.versions.modules, files: copiedFiles, bytes: copiedBytes, warnings: [...warnings], ...(omittedWarnings ? { omittedWarnings } : {}) }, null, 2) + '\n');
+}