@thomas.f/prnext 0.1.0-alpha.1

package/build/static-export.mjs

@@ -0,0 +1,93 @@
+import { mkdir, readFile, writeFile, cp, readdir, lstat, rename, rm } from 'node:fs/promises';
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+
+const marker = '.prnext-export.json';
+function filename(root, url) {
+  const parts = url.replace(/^\/+/, '').split('/').filter(Boolean).map(segment => {
+    const value = decodeURIComponent(segment);
+    if (value === '.' || value === '..' || /[\\/\0]/.test(value)) throw new Error('Invalid static export pathname');
+    return value;
+  });
+  return path.join(root, ...parts);
+}
+async function exists(file) { try { return await lstat(file); } catch (error) { if (error.code !== 'ENOENT') throw error; } }
+
+/** Only browser files and public response bodies enter an export, never runtime secrets. */
+export async function prepareStaticExport({ project, stage, manifest, config }) {
+  const reject = reason => { throw new Error(`output: 'export': ${reason}`); };
+  if (manifest.middleware) reject('middleware/proxy requires a server');
+  if (manifest.customRoutes.redirects.length || manifest.customRoutes.headers.length || Object.values(manifest.customRoutes.rewrites).some(value => value.length)) reject('headers, redirects and rewrites require a server');
+  if (Object.keys(manifest.app?.actions || {}).length) reject('Server Actions require a server');
+  const folder = path.join(stage, 'export');
+  await mkdir(folder);
+  const written = new Set();
+  async function put(url, contents, source) {
+    const file = filename(folder, url);
+    if (written.has(file) || await exists(file)) reject(`conflicting exported files at ${url}`);
+    written.add(file); await mkdir(path.dirname(file), { recursive: true });
+    if (source) await cp(source, file); else await writeFile(file, contents);
+  }
+  const mount = config.basePath || '';
+  const publicDirectory = path.join(project.root, 'public');
+  async function copyPublic(source, url) {
+    for (const item of await readdir(source, { withFileTypes: true })) {
+      if (item.isSymbolicLink()) reject(`public symlink ${item.name} cannot be exported`);
+      const next = url + '/' + item.name;
+      if (item.isDirectory()) await copyPublic(path.join(source, item.name), next);
+      else if (item.isFile()) await put(next, undefined, path.join(source, item.name));
+    }
+  }
+  if (await exists(publicDirectory)) await copyPublic(publicDirectory, mount);
+  const assets = /^https?:/.test(manifest.config.assetBase) ? '/_prnext/assets' : manifest.config.assetBase;
+  await mkdir(path.dirname(filename(folder, assets)), { recursive: true });
+  if (await exists(filename(folder, assets))) reject('public files overlap the framework assets');
+  await cp(path.join(stage, 'assets'), filename(folder, assets), { recursive: true });
+  for (const route of manifest.routes) {
+    if (route.internal) continue;
+    if (route.kind === 'api' && route.router !== 'app') reject(`Pages API ${route.pattern} requires a server`);
+    if (route.ssp || route.ppr || route.pprGeneric || route.dynamicPaths?.length || route.cacheConfig?.runtime === 'edge') reject(`${route.pattern} requires request-time rendering`);
+    if (route.pattern.includes('[') && (!route.ssg || route.router !== 'app' && route.fallback !== false)) reject(`${route.pattern} needs generated paths without fallback`);
+    if (!route.pattern.includes('[') && !manifest.prerendered.some(item => item.path === route.pattern)) reject(`${route.pattern} was not fully prerendered`);
+  }
+  for (const entry of manifest.prerendered) {
+    const route = manifest.routes.find(route => route.id === entry.routeId);
+    if (!route) reject(`missing route identity for ${entry.path}`);
+    if (route.errorStatus === 404 && manifest.appNotFound) continue;
+    if (route?.internal && !route.errorStatus && route.id !== manifest.appNotFound) continue;
+    if (entry.status >= 300 && ![404, 500].includes(entry.status)) reject(`redirect/error ${entry.path} cannot be a static response`);
+    if (entry.revalidate !== undefined && entry.revalidate !== false) reject(`ISR ${entry.path} requires a server`);
+    let pathname = entry.path.replace(/\/$/, '') || '/';
+    if (route?.errorStatus) pathname = '/' + route.errorStatus;
+    if (route?.id === manifest.appNotFound) pathname = '/404';
+    const body = await readFile(path.join(stage, entry.file));
+    if (route?.kind === 'api') { await put(mount + pathname, body); continue; }
+    let html = body.toString();
+    if (html.includes(config.images.path + '?')) reject(`optimized images in ${pathname} require images.unoptimized or a custom loader`);
+    html = html.replace(/<head(?:\s[^>]*)?>/i, value => value + '<script>window.__PRNEXT_STATIC_EXPORT__=true;</script>');
+    const output = pathname === '/' ? '/index.html' : config.trailingSlash && !['/404', '/500'].includes(pathname) ? pathname + '/index.html' : pathname + '.html';
+    await put(mount + output, html);
+    if (entry.dataFile) {
+      const data = await readFile(path.join(stage, entry.dataFile));
+      if (route?.router === 'app') await put(mount + '/_prnext/flight' + (pathname === '/' ? '' : pathname) + '/index.txt', data);
+      else for (const prefix of ['/_prnext/data/', '/_next/data/']) await put(mount + prefix + manifest.buildId + (pathname === '/' ? '/index' : pathname) + '.json', data);
+    }
+  }
+  await writeFile(path.join(folder, marker), JSON.stringify({ version: 1, buildId: manifest.buildId, basePath: mount, trailingSlash: config.trailingSlash }));
+  return folder;
+}
+
+export async function publishStaticExport(source, root) {
+  const destination = path.join(root, 'out'), backup = path.join(root, '.prnext-export-backup-' + randomUUID());
+  const previous = await exists(destination);
+  if (previous) {
+    if (!previous.isDirectory() || previous.isSymbolicLink() || !await exists(path.join(destination, marker))) throw new Error('Refusing to replace out/: it is not a PRNext static export');
+    await rename(destination, backup);
+  }
+  try { await rename(source, destination); }
+  catch (error) { if (previous) await rename(backup, destination); throw error; }
+  return {
+    async rollback() { await rename(destination, source); if (previous) await rename(backup, destination); },
+    async commit() { if (previous) await rm(backup, { recursive: true, force: true }); },
+  };
+}

package/build/styles.mjs

@@ -0,0 +1,174 @@
+import { build as bundle } from 'esbuild';
+import { access, readFile, readdir, writeFile, rm } from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import { randomUUID } from 'node:crypto';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import path from 'node:path';
+import postcss from 'postcss';
+import valueParser from 'postcss-value-parser';
+import flexbugs from 'postcss-flexbugs-fixes';
+import presetEnv from 'postcss-preset-env';
+
+export const stylesheetPattern = /\.(?:css|scss|sass)$/i;
+export const moduleStylesheetPattern = /\.module\.(?:css|scss|sass)$/i;
+const configPattern = /^(?:postcss\.config|\.postcssrc)\.(?:js|mjs|cjs|json)$/;
+
+async function importConfiguration(filename) {
+  const temporary = path.join(path.dirname(filename), `.prnext-postcss-${randomUUID()}.mjs`);
+  try {
+    // Bundle local helpers afresh so an in-process rebuild sees their changes.
+    const result = await bundle({ entryPoints: [filename], bundle: true, write: false,
+      platform: 'node', target: 'node22', format: 'esm', packages: 'external', logLevel: 'silent',
+      define: { 'import.meta.url': JSON.stringify(pathToFileURL(filename).href), __filename: JSON.stringify(filename), __dirname: JSON.stringify(path.dirname(filename)) },
+      banner: { js: `import {createRequire as __prnextCreateRequire} from 'node:module';const require=__prnextCreateRequire(${JSON.stringify(pathToFileURL(filename).href)});` } });
+    await writeFile(temporary, result.outputFiles[0].contents, { flag: 'wx' });
+    return (await import(pathToFileURL(temporary).href)).default;
+  } finally { await rm(temporary, { force: true }); }
+}
+
+async function loadConfiguration(root) {
+  const filenames = (await readdir(root)).filter(name => configPattern.test(name) || name === '.postcssrc');
+  let metadata;
+  try { metadata = JSON.parse(await readFile(path.join(root, 'package.json'), 'utf8')); }
+  catch (error) { if (error.code !== 'ENOENT') throw error; }
+  if (filenames.length > 1 || (filenames.length && metadata?.postcss !== undefined)) throw new Error('Multiple PostCSS configurations found. Keep one postcss.config.*, .postcssrc*, or package.json postcss entry.');
+  if (!filenames.length) return metadata?.postcss;
+  const filename = path.join(root, filenames[0]);
+  return /\.(?:js|mjs|cjs)$/.test(filename) ? importConfiguration(filename) : JSON.parse(await readFile(filename, 'utf8'));
+}
+
+async function createProcessor(root) {
+  const config = await loadConfiguration(root);
+  if (config === undefined) return postcss([flexbugs(), presetEnv({ autoprefixer: { flexbox: 'no-2009' }, stage: 3, features: { 'custom-properties': false } })]);
+  if (!config || typeof config !== 'object' || Array.isArray(config) || !config.plugins || typeof config.plugins !== 'object') throw new Error('PostCSS configuration must export an object with a plugins object or array; configuration functions are not supported.');
+  const entries = Array.isArray(config.plugins)
+    ? config.plugins.filter(item => item != null).map(item => typeof item === 'string' ? [item, true] : item)
+    : Object.entries(config.plugins);
+  const require = createRequire(path.join(root, 'package.json'));
+  const plugins = [];
+  for (const item of entries) {
+    if (!Array.isArray(item) || typeof item[0] !== 'string' || item.length !== 2 || item[1] == null || !['object', 'boolean', 'string'].includes(typeof item[1])) throw new Error('PostCSS plugins must be names or [name, options] pairs, with false to disable a plugin.');
+    const [name, configuredOptions] = item;
+    const options = name === '@tailwindcss/postcss' && configuredOptions !== false
+      ? { base: root, ...(typeof configuredOptions === 'object' ? configuredOptions : {}) } : configuredOptions;
+    if (options === false) continue;
+    if (/^(?:postcss-modules|postcss-modules-(?:values|scope|extract-imports|local-by-default))$/.test(name)) throw new Error(`${name} duplicates PRNext CSS Modules processing. Remove it from the PostCSS configuration.`);
+    let filename;
+    try { filename = require.resolve(name); }
+    catch (cause) { throw new Error(`PostCSS plugin ${name} is missing from the application. Install it in ${root}.`, { cause }); }
+    const imported = await import(pathToFileURL(filename).href);
+    const plugin = imported.default || imported;
+    plugins.push(options === true || (typeof options === 'object' && Object.keys(options).length === 0)
+      ? (plugin.postcss === true ? plugin() : plugin) : typeof plugin === 'function' ? plugin(options) : plugin);
+  }
+  return postcss(plugins);
+}
+
+function rebaseReferences(root, file) {
+  const rebase = (value, node) => {
+    if (!value || /^(?:[a-z][a-z\d+.-]*:|\/|#|var\()/i.test(value)) return value;
+    let source = node.source?.input?.file || file;
+    const position = node.source?.start;
+    if (position && node.source.input.map) source = node.source.input.origin(position.line, position.column)?.file || source;
+    if (source.startsWith('file:')) source = fileURLToPath(source);
+    if (path.dirname(source) === path.dirname(file)) return value;
+    const suffixIndex = value.search(/[?#]/);
+    const pathname = suffixIndex < 0 ? value : value.slice(0, suffixIndex);
+    const suffix = suffixIndex < 0 ? '' : value.slice(suffixIndex);
+    let relative = path.relative(path.dirname(file), path.resolve(path.dirname(source), pathname)).replaceAll(path.sep, '/');
+    if (!relative.startsWith('.')) relative = './' + relative;
+    return relative + suffix;
+  };
+  const values = (value, owner, imports = false) => {
+    const parsed = valueParser(value);
+    parsed.walk(node => {
+      if (node.type === 'function' && node.value.toLowerCase() === 'url') {
+        const child = node.nodes.find(part => part.type === 'string' || part.type === 'word');
+        if (child && node.nodes.filter(part => !['space', 'comment'].includes(part.type)).length === 1) child.value = rebase(child.value, owner);
+        return false;
+      }
+    });
+    if (imports) {
+      const first = parsed.nodes.find(node => !['space', 'comment'].includes(node.type));
+      if (first?.type === 'string') first.value = rebase(first.value, owner);
+    }
+    return parsed.toString();
+  };
+  root.walkDecls(node => { if (/url\(/i.test(node.value)) node.value = values(node.value, node); });
+  root.walkAtRules('import', node => { node.params = values(node.params, node, true); });
+}
+
+async function canAccess(filename) {
+  try { await access(filename); return true; } catch { return false; }
+}
+
+function packageImporter(require) {
+  return { async findFileUrl(url) {
+    if (/^(?:\.|\/|[a-z][a-z\d+.-]*:)/i.test(url)) return null;
+    const specifier = url.replace(/^~/, '');
+    const parts = specifier.split('/');
+    const name = parts.splice(0, specifier.startsWith('@') ? 2 : 1).join('/');
+    for (const directory of require.resolve.paths(name) || []) {
+      const packageDirectory = path.join(directory, name);
+      if (!await canAccess(packageDirectory)) continue;
+      if (parts.length) return pathToFileURL(path.join(packageDirectory, ...parts));
+      let metadata;
+      try { metadata = JSON.parse(await readFile(path.join(packageDirectory, 'package.json'), 'utf8')); } catch {}
+      const entry = metadata?.sass || metadata?.style || 'index';
+      return pathToFileURL(path.join(packageDirectory, entry));
+    }
+    return null;
+  } };
+}
+
+/** Build-only transformations, shared and deduplicated across all three React graphs. */
+export function createStyleProcessor({ projectRoot, sassOptions = {} }) {
+  const root = path.resolve(projectRoot);
+  const require = createRequire(path.join(root, 'package.json'));
+  const cache = new Map();
+  let processor;
+  let sass;
+  async function transform(file) {
+    let css = await readFile(file, 'utf8');
+    let sourceMap;
+    const dependencies = new Set([file]);
+    if (/\.s[ac]ss$/i.test(file)) {
+      const { implementation = 'sass', additionalData = '', includePaths = [], loadPaths = [], outputStyle, ...options } = sassOptions;
+      if (!['sass', 'sass-embedded'].includes(implementation)) throw new Error('sassOptions.implementation must be sass or sass-embedded.');
+      if (!sass) {
+        let filename;
+        try { filename = require.resolve(implementation); }
+        catch (cause) { throw new Error(`Sass stylesheet ${file} requires ${implementation} in the application. Install it with npm install --save-dev ${implementation}.`, { cause }); }
+        sass = import(pathToFileURL(filename).href);
+      }
+      const imported = await sass;
+      const compiler = imported.compileStringAsync ? imported : imported.default;
+      if (typeof additionalData === 'function') css = await additionalData(css, { resourcePath: file, rootContext: root });
+      else if (typeof additionalData === 'string') css = additionalData + '\n' + css;
+      else throw new Error('sassOptions.additionalData must be a string or function.');
+      if (typeof css !== 'string') throw new Error('sassOptions.additionalData must return a string.');
+      const compiled = await compiler.compileStringAsync(css, { ...options, ...(outputStyle ? { style: outputStyle } : {}),
+        url: pathToFileURL(file), syntax: file.endsWith('.sass') ? 'indented' : 'scss',
+        loadPaths: [...includePaths, ...loadPaths].map(directory => path.resolve(root, directory)),
+        importers: [...(options.importers || []), packageImporter(require), ...(compiler.NodePackageImporter ? [new compiler.NodePackageImporter(root)] : [])],
+        sourceMap: true, sourceMapIncludeSources: true });
+      css = compiled.css;
+      sourceMap = compiled.sourceMap;
+      for (const url of compiled.loadedUrls) if (url.protocol === 'file:') dependencies.add(fileURLToPath(url));
+    }
+    processor ??= createProcessor(root);
+    const processed = await (await processor).process(css, { from: file, to: file, map: sourceMap ? { prev: sourceMap, inline: false, annotation: false } : false });
+    for (const message of processed.messages) if (message.type === 'dependency' && message.file) dependencies.add(path.resolve(root, message.file));
+    rebaseReferences(processed.root, file);
+    const exports = Object.create(null);
+    if (moduleStylesheetPattern.test(file)) processed.root.walkRules(':export', rule => {
+      rule.walkDecls(declaration => { exports[declaration.prop] = declaration.value; });
+      rule.remove();
+    });
+    return { css: processed.root.toString(), exports, watchFiles: [...dependencies] };
+  }
+  return { process(file) {
+    if (!cache.has(file)) cache.set(file, transform(file));
+    return cache.get(file);
+  } };
+}

package/build/transform-cache.mjs

@@ -0,0 +1,50 @@
+import { createHash } from 'node:crypto';
+import {sourceMapsEnabled} from './source-maps.mjs';
+
+const entries = new Map();
+const byteLimit = 2 * 1024 * 1024, entryLimit = 256, itemLimit = 128 * 1024;
+let bytes = 0, hits = 0, misses = 0;
+export const transformCacheStats = () => ({entries:entries.size,bytes,hits,misses});
+
+// Only pure string transformations belong here. No AST, input source, plugin
+// closure or mutable build metadata survives in the cache. Include all options
+// affecting output in settings, including build identity and target mode.
+export function cachedTransform(kind, source, settings, transform) {
+  const key = createHash('sha256').update(JSON.stringify([kind,settings,sourceMapsEnabled()])).update('\0').update(source).digest('hex');
+  const found = entries.get(key);
+  if (found) {
+    hits++; entries.delete(key); entries.set(key,found);
+    return found.output;
+  }
+  misses++;
+  const output = transform();
+  // UTF-16 is an upper bound for the retained string payload. Metadata adds
+  // engine overhead; the entry count also bounds that overhead.
+  const size = output.length * 2 + key.length * 2;
+  if (size <= itemLimit) {
+    while (entries.size && (entries.size >= entryLimit || bytes + size > byteLimit)) {
+      const [oldest,value] = entries.entries().next().value;
+      entries.delete(oldest); bytes -= value.size;
+    }
+    entries.set(key,{output,size}); bytes += size;
+  }
+  return output;
+}
+
+/** Async transforms share the same payload and entry budget as synchronous ones. */
+export async function cachedAsyncTransform(kind, source, settings, transform) {
+  const key = createHash('sha256').update(JSON.stringify([kind,settings,sourceMapsEnabled()])).update('\0').update(source).digest('hex');
+  const found = entries.get(key);
+  if (found) { hits++; entries.delete(key); entries.set(key,found); return found.output; }
+  misses++;
+  const output = await transform();
+  const size = output.length * 2 + key.length * 2;
+  if (size <= itemLimit) {
+    if (entries.has(key)) {bytes -= entries.get(key).size;entries.delete(key);}
+    while (entries.size && (entries.size >= entryLimit || bytes + size > byteLimit)) {
+      const [oldest,value] = entries.entries().next().value;entries.delete(oldest);bytes -= value.size;
+    }
+    entries.set(key,{output,size});bytes += size;
+  }
+  return output;
+}

package/build/transform.mjs

@@ -0,0 +1,155 @@
+import {generateMapped,sourceMapsEnabled,extractSourceMap,inlineSourceMap} from './source-maps.mjs';
+import {readFile,writeFile} from 'node:fs/promises';
+import path from 'node:path';
+import { parse } from '@babel/parser';
+import traverseModule from '@babel/traverse';
+import generateModule from '@babel/generator';
+import * as t from '@babel/types';
+import { cachedTransform } from './transform-cache.mjs';
+
+const traverse = traverseModule.default || traverseModule;
+const generate = generateModule.default || generateModule;
+const serverExports = new Set(['getServerSideProps', 'getStaticProps', 'getStaticPaths']);
+
+/** esbuild uses publicPath for both assets and chunks; Node needs relative chunk imports. */
+export function relativeServerChunkImports(source, chunks, publicPath = '/_prnext/assets') {
+  const prefix = publicPath.replace(/\/+$/, '') + '/';
+  if (!source.includes(prefix)) return source;
+  return cachedTransform('chunk-imports',source,[[...chunks].sort(),prefix],()=>relativeChunksUncached(source,chunks,prefix));
+}
+function relativeChunksUncached(source,chunks,prefix) {
+  const edits = [];
+  const ast = parse(source, { sourceType: 'module' });
+  function rewrite(node) {
+    if (!node || !t.isStringLiteral(node) || !node.value.startsWith(prefix)) return;
+    const name = node.value.slice(prefix.length);
+    if (chunks.has(name)) {edits.push({ start: node.start, end: node.end, text: JSON.stringify('./' + name) });node.value='./'+name;delete node.extra;}
+  }
+  traverse(ast, {
+    ImportDeclaration(path) { rewrite(path.node.source); },
+    ExportNamedDeclaration(path) { rewrite(path.node.source); },
+    ExportAllDeclaration(path) { rewrite(path.node.source); },
+    CallExpression(path) { if (t.isImport(path.node.callee)) rewrite(path.node.arguments[0]); },
+  });
+  if(edits.length && sourceMapsEnabled() && extractSourceMap(source).map)return generateMapped(generate,ast,{comments:true},source,'bundle.mjs');
+  // Replacing only generated specifiers preserves every source line and asset URL.
+  for (const edit of edits.sort((left, right) => right.start - left.start)) source = source.slice(0, edit.start) + edit.text + source.slice(edit.end);
+  return source;
+}
+
+export async function rewriteServerChunks(file,chunks,publicPath){
+  const source=await readFile(file,'utf8');
+  if(!source.includes(publicPath.replace(/\/+$/,'')+'/'))return;
+  let map;
+  if(sourceMapsEnabled())try{map=JSON.parse(await readFile(file+'.map','utf8'));}catch(error){if(error.code!=='ENOENT')throw error;}
+  const result=relativeServerChunkImports(inlineSourceMap(source,map),chunks,publicPath);
+  if(map){
+    const mapped=extractSourceMap(result);
+    await writeFile(file+'.map',JSON.stringify({...mapped.map,file:path.basename(file)}));
+    await writeFile(file,mapped.code.replace(/\/\/[#@]\s*sourceMappingURL=[^\s]+/g,'')+'\n//# sourceMappingURL='+path.basename(file)+'.map\n');
+  }else await writeFile(file,result);
+}
+
+function parserOptions(filename) {
+  return { sourceType: 'unambiguous', sourceFilename: filename, plugins: ['jsx', ...( /\.tsx?$/.test(filename) ? ['typescript'] : [])] };
+}
+
+export function assertSupportedSource(source, filename) {
+  if (!source.includes('use server')) return;
+  const ast = parse(source, parserOptions(filename));
+  traverse(ast, {
+    Directive(path) {
+      if (path.node.value.value === 'use server') throw new Error(`Server Actions ("use server") are not supported in the Pages Router: ${filename}. Move this action to app/ or use pages/api.`);
+    },
+  });
+}
+
+/** Strip loader exports and the now-unused dependency graph before esbuild sees a browser page. */
+export function stripServerCode(source, filename = 'page.tsx') {
+  return cachedTransform('pages-strip',source,[filename],()=>stripServerCodeUncached(source,filename));
+}
+
+function stripServerCodeUncached(source, filename) {
+  const ast = parse(source, parserOptions(filename));
+  let program;
+  traverse(ast, { Program(path) { program = path; path.stop(); } });
+  const candidates = new Set();
+  const loaders = new Set();
+  const exportPaths = [];
+
+  function collect(binding) {
+    if (!binding || binding.scope !== program.scope || candidates.has(binding.identifier.name)) return;
+    candidates.add(binding.identifier.name);
+    binding.path.traverse({
+      ReferencedIdentifier(ref) { collect(ref.scope.getBinding(ref.node.name)); },
+    });
+  }
+
+  for (const statement of program.get('body')) {
+    if (!statement.isExportNamedDeclaration()) continue;
+    const declaration = statement.get('declaration');
+    if (declaration?.node) {
+      for (const name of Object.keys(t.getBindingIdentifiers(declaration.node))) {
+        if (serverExports.has(name)) { loaders.add(name); collect(program.scope.getBinding(name)); }
+      }
+    }
+    for (const specifier of statement.get('specifiers')) {
+      const exported = specifier.node.exported?.name ?? specifier.node.exported?.value;
+      if (!serverExports.has(exported)) continue;
+      if (specifier.node.local) {
+        loaders.add(specifier.node.local.name);
+        collect(program.scope.getBinding(specifier.node.local.name));
+      }
+      exportPaths.push(specifier);
+    }
+  }
+
+  for (const specifier of exportPaths) {
+    const declaration = specifier.parentPath;
+    specifier.remove();
+    if (!declaration.node.specifiers.length && !declaration.node.declaration) declaration.remove();
+  }
+  for (const name of loaders) {
+    const binding = program.scope.getBinding(name);
+    if (!binding) continue;
+    if (binding.path.isImportSpecifier() || binding.path.isImportDefaultSpecifier() || binding.path.isImportNamespaceSpecifier()) {
+      const declaration = binding.path.parentPath;
+      binding.path.remove();
+      if (!declaration.node.specifiers.length) declaration.remove();
+    } else if (binding.path.isVariableDeclarator()) {
+      const declaration = binding.path.parentPath;
+      if (declaration.node.declarations.length === 1 && declaration.parentPath.isExportNamedDeclaration()) declaration.parentPath.remove();
+      else binding.path.remove();
+    } else if (binding.path.parentPath.isExportNamedDeclaration()) binding.path.parentPath.remove();
+    else binding.path.remove();
+  }
+
+  // Iteration matters: deleting an unused helper can make its database import unused.
+  let changed = true;
+  while (changed) {
+    changed = false;
+    program.scope.crawl();
+    for (const name of candidates) {
+      const binding = program.scope.getBinding(name);
+      if (!binding || binding.referenced) continue;
+      const declaration = binding.path;
+      if (declaration.isImportSpecifier() || declaration.isImportDefaultSpecifier() || declaration.isImportNamespaceSpecifier()) {
+        const parent = declaration.parentPath;
+        declaration.remove();
+        if (!parent.node.specifiers.length) parent.remove();
+      } else if (declaration.isVariableDeclarator()) {
+        // A destructuring pattern may contain bindings still used by the page.
+        const names = Object.keys(t.getBindingIdentifiers(declaration.node.id));
+        if (names.some(id => program.scope.getBinding(id)?.referenced)) continue;
+        declaration.remove();
+      } else if (declaration.isFunctionDeclaration() || declaration.isClassDeclaration()) declaration.remove();
+      else continue;
+      changed = true;
+    }
+  }
+  // A star export cannot be safely classified without evaluating another module.
+  if (program.get('body').some(statement => statement.isExportAllDeclaration())) {
+    throw new Error(`Wildcard re-exports in a page are not supported: ${filename}. Explicitly export the page and its data loaders so server code can be excluded from the browser.`);
+  }
+  return generateMapped(generate, ast, { comments: true }, source, filename);
+}

package/build/turbopack-conditions.mjs

@@ -0,0 +1,59 @@
+import path from 'node:path';
+import picomatch from 'picomatch';
+import {readFile} from 'node:fs/promises';
+import {fileURLToPath} from 'node:url';
+
+const builtins = new Set(['browser','foreign','development','production','node','edge-light']);
+const frameworkRoot=fileURLToPath(new URL('../',import.meta.url));
+export function validateCondition(value, depth = 0, budget = {remaining:256}) {
+  if (depth > 32 || --budget.remaining < 0) throw new TypeError('Turbopack condition is too complex');
+  if (typeof value === 'string' && builtins.has(value)) return;
+  if (!value || typeof value !== 'object' || Array.isArray(value) || value instanceof RegExp) throw new TypeError('Invalid Turbopack condition');
+  const keys = Object.keys(value);
+  if (keys.length === 1 && ['all','any','not'].includes(keys[0])) {
+    const key = keys[0];
+    if (key === 'not') return validateCondition(value.not,depth+1,budget);
+    if (!Array.isArray(value[key])) throw new TypeError(`Turbopack condition ${key} must be an array`);
+    for (const child of value[key]) validateCondition(child,depth+1,budget);
+    return;
+  }
+  if (!keys.length || keys.some(key=>!['path','content'].includes(key)) ||
+      ('path' in value && !(value.path instanceof RegExp) && typeof value.path !== 'string') ||
+      ('content' in value && !(value.content instanceof RegExp))) throw new TypeError('Invalid Turbopack path/content condition');
+}
+
+const regex = (pattern,value) => {pattern.lastIndex=0;return pattern.test(value);};
+const glob = pattern => {const match=picomatch(pattern);return file=>match(pattern.includes('/')?file:path.posix.basename(file));};
+function compileCondition(value, state, target) {
+  if (typeof value === 'string') {
+    if (value === 'foreign') return async file=>/(^|\/)node_modules\//.test(file) || path.resolve(state.root,file).startsWith(frameworkRoot);
+    const enabled={browser:target==='browser',node:target==='node','edge-light':target==='edge',development:!!state.dev,production:!state.dev}[value];
+    return async()=>enabled;
+  }
+  if (value.not) {const child=compileCondition(value.not,state,target);return async(file,read)=>!await child(file,read);}
+  if (value.all || value.any) {
+    const all=!!value.all, children=(value.all || value.any).map(child=>compileCondition(child,state,target));
+    return async(file,read)=>{for(const child of children)if(await child(file,read)!==all)return !all;return all;};
+  }
+  const match=value.path instanceof RegExp?file=>regex(value.path,file):typeof value.path==='string'?glob(value.path):()=>true;
+  return async(file,read)=>match(file) && (!value.content || regex(value.content,await read()));
+}
+
+// Conditions read source only when a content predicate is actually reached.
+// No file contents survive selection, and boolean operators short-circuit.
+export function turbopackRules(rules, state, target) {
+  const root = state.config?.turbopack?.root || state.root;
+  const conditionState = {...state,root};
+  return Object.entries(rules || {}).flatMap(([pattern,entries])=>{
+    const match=glob(pattern);
+    return (Array.isArray(entries)?entries:[entries]).map(rule=>{
+      const predicate=rule.condition===undefined?async()=>true:compileCondition(rule.condition,conditionState,target);
+      return {test:file=>match(path.relative(root,file).replaceAll(path.sep,'/')),use:rule.loaders,
+        prnextCondition:async(file,read)=>predicate(path.relative(root,file).replaceAll(path.sep,'/'),read)};
+    });
+  });
+}
+export function sourceReader(file) {
+  let source;
+  return ()=>source ||= readFile(file,'utf8');
+}

package/build/webpack-bridge.cjs

@@ -0,0 +1,3 @@
+// Per-compilation bridges are released when webpack closes. Nothing is global
+// in the generated application or retained by the production server.
+exports.active = new Map();