@thomas.f/prnext 0.1.0-alpha.1

package/build/module-resolution.mjs

@@ -0,0 +1,78 @@
+import path from 'node:path';
+import {validateCondition} from './turbopack-conditions.mjs';
+import {frameworkImportPattern} from './framework-imports.mjs';
+
+const reserved = name => frameworkImportPattern.test(name) || /^(?:react|react-dom|react-server-dom-webpack)(?:\/|$)/.test(name);
+export function validateWebpackResolution(input = {}) {
+  for(const key of Object.keys(input))if(!['alias','extensions'].includes(key))throw new Error(`webpack.resolve.${key} is not implemented`);
+  const aliases=input.alias || {};
+  if (!aliases || typeof aliases!=='object' || Array.isArray(aliases) || Object.keys(aliases).length>256)throw new TypeError('webpack.resolve.alias must contain at most 256 aliases');
+  for(const [key,value]of Object.entries(aliases)){
+    const name=key.endsWith('$')?key.slice(0,-1):key;
+    if (!name || name.length>4096 || /[\0*$]/.test(name) || reserved(name))throw new TypeError(`Unsupported webpack.resolve.alias key ${key}`);
+    const values=Array.isArray(value)?value:[value];
+    if(!values.length || values.length>32 || values.some(value=>value!==false && (typeof value!=='string' || !value || value.length>4096 || /[\0*]/.test(value))))throw new TypeError(`Invalid webpack.resolve.alias.${key}`);
+  }
+  const extensions=validateTurbopack({resolveExtensions:input.extensions}).resolveExtensions;
+  return {resolveAlias:aliases,aliasesRelativeToImporter:true,...(extensions?{resolveExtensions:extensions}:{})};
+}
+export function validateTurbopack(input = {}) {
+  if (!input || typeof input !== 'object' || Array.isArray(input)) throw new TypeError('turbopack must be an object');
+  for (const key of Object.keys(input)) if (!['root', 'resolveAlias', 'resolveExtensions', 'rules'].includes(key)) throw new Error(`turbopack.${key} is not implemented by PRNext`);
+  if (input.root !== undefined && (typeof input.root !== 'string' || !path.isAbsolute(input.root) || input.root.includes('\0'))) throw new TypeError('turbopack.root must be an absolute filesystem path');
+  const aliases = input.resolveAlias ?? {};
+  if (!aliases || typeof aliases !== 'object' || Array.isArray(aliases) || Object.keys(aliases).length > 256) throw new TypeError('turbopack.resolveAlias must contain at most 256 aliases');
+  const validTarget = target => typeof target === 'string' && target.length > 0 && target.length <= 4096 && !/[\0*]/.test(target);
+  for (const [name, target] of Object.entries(aliases)) {
+    if (!name || name.length > 4096 || /[\0*$]/.test(name) || reserved(name)) throw new TypeError(`Unsupported turbopack.resolveAlias key ${name}; framework aliases and wildcard aliases cannot be overridden`);
+    if (!validTarget(target) && (!target || typeof target !== 'object' || Array.isArray(target) || Object.keys(target).length !== 1 || !validTarget(target.browser))) throw new TypeError(`turbopack.resolveAlias.${name} must be a path/package string or {browser: string}`);
+  }
+  const extensions = input.resolveExtensions;
+  if (extensions !== undefined && (!Array.isArray(extensions) || !extensions.length || extensions.length > 32 || extensions.some(value => typeof value !== 'string' || !/^\.[a-zA-Z0-9.]+$/.test(value)))) throw new TypeError('turbopack.resolveExtensions must be an array of at most 32 file extensions');
+  const rules = input.rules;
+  if (rules !== undefined) {
+    if (!rules || typeof rules !== 'object' || Array.isArray(rules) || Object.keys(rules).length > 256) throw new TypeError('turbopack.rules must contain at most 256 patterns');
+    let count=0;
+    for (const [pattern, entries] of Object.entries(rules)) {
+      const variants=Array.isArray(entries)?entries:[entries];
+      if (!variants.length || (count+=variants.length)>256) throw new TypeError('turbopack.rules must contain at most 256 nonempty rule variants');
+      for (const rule of variants) {
+      if (!pattern || pattern.length > 1024 || !rule || typeof rule !== 'object' || Object.keys(rule).some(key => !['loaders', 'as', 'condition'].includes(key)) || !Array.isArray(rule.loaders) || !rule.loaders.length || rule.loaders.length > 32 || rule.loaders.some(loader => typeof loader !== 'string' && (!loader || typeof loader.loader !== 'string' || Object.keys(loader).some(key => !['loader','options'].includes(key))))) throw new TypeError(`Invalid turbopack.rules ${pattern}; expected a loaders array and optional as/condition`);
+      if (rule.as !== undefined && !['*.js', '*.jsx'].includes(rule.as)) throw new Error('Turbopack loader output must be JavaScript (*.js or *.jsx)');
+      if (rule.condition !== undefined) validateCondition(rule.condition);
+      }
+    }
+  }
+  return { ...(input.root !== undefined ? {root:path.resolve(input.root)} : {}), ...(rules ? {rules} : {}), resolveAlias: aliases, ...(extensions ? { resolveExtensions: [...new Set(extensions)] } : {}) };
+}
+
+/** Resolve aliases before boundary analysis so every graph uses the same module identity. */
+export function moduleResolutionPlugin(config = {}, projectRoot) {
+  const aliases = Object.entries(config.resolveAlias || {}).sort(([a], [b]) => b.length - a.length);
+  return { name: 'prnext-module-resolution', setup(build) {
+    if (config.resolveExtensions) build.initialOptions.resolveExtensions = config.resolveExtensions;
+    if (!aliases.length) return;
+    build.onResolve({ filter: /.*/ }, async args => {
+      if (args.pluginData?.prnextAlias || args.namespace && args.namespace !== 'file') return;
+      const match = aliases.find(([name]) => name.endsWith('$') ? args.path===name.slice(0,-1) : args.path === name || args.path.startsWith(name + '/'));
+      if (!match) return;
+      const [name, value] = match;
+      const targets = Array.isArray(value)?value:[typeof value === 'string' || value===false ? value : build.initialOptions.platform === 'browser' ? value.browser : undefined];
+      let resolved;
+      for(const target of targets){
+      if (target===false) return {path:args.path,namespace:'prnext-ignored-alias'};
+      if (target===undefined) return;
+      const replacement = target + args.path.slice(name.endsWith('$')?name.length-1:name.length);
+      const resolveDir = config.aliasesRelativeToImporter ? args.resolveDir || projectRoot : config.root || projectRoot;
+      resolved = await build.resolve(replacement.startsWith('.') ? path.resolve(resolveDir, replacement) : replacement, {
+        importer: args.importer, namespace: args.namespace, resolveDir,
+        kind: args.kind, with: args.with, pluginData: { ...args.pluginData, prnextAlias: true },
+      });
+      if(!resolved.errors.length)break;
+      }
+      // Do not leak the recursion guard to imports made by the aliased module.
+      return { ...resolved, pluginData: args.pluginData };
+    });
+    build.onLoad({filter:/.*/,namespace:'prnext-ignored-alias'},()=>({contents:'module.exports = {};',loader:'js'}));
+  } };
+}

package/build/native-discovery.mjs

@@ -0,0 +1,134 @@
+import { readdir, readFile, realpath } from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+
+/** Inspect only packages reached through imports and declared runtime dependencies. */
+export function createNativeDiscovery({ projectRoot, isClientSource }) {
+  const metadata = new Map();
+  const packageRoots = new Map();
+  const packageFiles = new Map();
+  const dependencyRoots = new Map();
+  const clientBoundaries = new Map();
+
+  function readMetadata(directory) {
+    if (!metadata.has(directory)) metadata.set(directory, readFile(path.join(directory, 'package.json'), 'utf8').then(JSON.parse).catch(error => {
+      if (error.code === 'ENOENT' || error.code === 'ENOTDIR') return;
+      throw error;
+    }));
+    return metadata.get(directory);
+  }
+
+  async function packageFor(file) {
+    let directory = path.dirname(file);
+    const visited = [];
+    for (;;) {
+      if (packageRoots.has(directory)) {
+        const cached = packageRoots.get(directory);
+        for (const current of visited) packageRoots.set(current, cached);
+        return cached;
+      }
+      visited.push(directory);
+      const info = await readMetadata(directory);
+      if (typeof info?.name === 'string') {
+        const result = { directory, name: info.name, metadata: info };
+        for (const current of visited) packageRoots.set(current, result);
+        return result;
+      }
+      const parent = path.dirname(directory);
+      if (parent === directory) return;
+      directory = parent;
+    }
+  }
+
+  function filesFor(directory) {
+    if (!packageFiles.has(directory)) packageFiles.set(directory, (async () => {
+      const result = { native: false, css: false, sources: [] };
+      async function walk(current) {
+        for (const entry of await readdir(current, { withFileTypes: true })) {
+          if (entry.name === 'node_modules' || entry.name === '.git') continue;
+          const file = path.join(current, entry.name);
+          // Follow declared dependencies independently; avoid walking symlinked
+          // directories into another package or revisiting directory cycles.
+          if (entry.isDirectory()) await walk(file);
+          else if (entry.isFile() || entry.isSymbolicLink()) {
+            if (entry.name.endsWith('.node')) result.native = true;
+            if (/\.(?:css|scss|sass)$/i.test(entry.name)) result.css = true;
+            if (/\.(?:[cm]?js|jsx|tsx?)$/.test(entry.name) && !entry.name.endsWith('.d.ts')) result.sources.push(file);
+          }
+        }
+      }
+      await walk(directory);
+      return result;
+    })());
+    return packageFiles.get(directory);
+  }
+
+  async function resolveDependency(directory, name) {
+    const key = directory + '\0' + name;
+    if (!dependencyRoots.has(key)) dependencyRoots.set(key, (async () => {
+      const require = createRequire(path.join(directory, 'package.json'));
+      try {
+        const file = require.resolve(name);
+        if (path.isAbsolute(file)) return packageFor(file);
+      } catch (error) {
+        if (!['MODULE_NOT_FOUND', 'ERR_PACKAGE_PATH_NOT_EXPORTED'].includes(error.code)) throw error;
+      }
+      // Packages with only conditional/subpath exports still have runtime
+      // dependencies; locate their metadata without importing or evaluating them.
+      for (const search of require.resolve.paths(name) || []) {
+        const candidate = path.join(search, name);
+        const info = await readMetadata(candidate);
+        if (typeof info?.name === 'string') {
+          const directory = await realpath(candidate);
+          return { directory, name: info.name, metadata: info };
+        }
+      }
+    })());
+    return dependencyRoots.get(key);
+  }
+
+  async function nativeReachable(owner, visited = new Set()) {
+    if (visited.has(owner.directory)) return false;
+    visited.add(owner.directory);
+    if ((await filesFor(owner.directory)).native) return true;
+    const names = new Set([...Object.keys(owner.metadata.dependencies || {}), ...Object.keys(owner.metadata.optionalDependencies || {})]);
+    for (const name of names) {
+      const dependency = await resolveDependency(owner.directory, name);
+      if (dependency && await nativeReachable(dependency, visited)) return true;
+    }
+    return false;
+  }
+
+  function hasClientBoundary(directory, sources) {
+    if (!clientBoundaries.has(directory)) clientBoundaries.set(directory, (async () => {
+      for (const file of sources) {
+        const source = await readFile(file, 'utf8');
+        if ((source.includes('use client') || source.includes('use server')) && isClientSource(source, file)) return true;
+      }
+      return false;
+    })());
+    return clientBoundaries.get(directory);
+  }
+
+  async function canExternalizeDirectory(directory, mode) {
+    const ownFiles = await filesFor(directory);
+    return !ownFiles.css && !await hasClientBoundary(directory, ownFiles.sources);
+  }
+
+  return {
+    canExternalizeDirectory,
+    async externalOwner(file, mode) {
+      const owner = await packageFor(file);
+      if (!owner) return;
+      const application = path.relative(owner.directory, projectRoot);
+      if (application === '' || (!application.startsWith('..' + path.sep) && application !== '..' && !path.isAbsolute(application))) return;
+      if (!await nativeReachable(owner)) return;
+      // Keep CSS extraction and Server Component client-reference transforms in
+      // the compiler. A native dependency imported by this package is examined
+      // separately when its own entry is resolved.
+      if (!await canExternalizeDirectory(owner.directory, mode)) return;
+      if (!/\.[cm]?js$/.test(file)) return;
+      return { directory: owner.directory, name: owner.name };
+    },
+  };
+}

package/build/native-packages.mjs

@@ -0,0 +1,105 @@
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { createNativeDiscovery } from './native-discovery.mjs';
+
+function contains(directory, file) {
+  const relative = path.relative(directory, file);
+  return relative === '' || (!relative.startsWith('..' + path.sep) && relative !== '..' && !path.isAbsolute(relative));
+}
+
+async function packageAt(directory) {
+  try {
+    const metadata = JSON.parse(await readFile(path.join(directory, 'package.json'), 'utf8'));
+    return typeof metadata.name === 'string' ? { directory, name: metadata.name } : undefined;
+  } catch (error) {
+    if (error.code === 'ENOENT' || error.code === 'ENOTDIR') return;
+    throw error;
+  }
+}
+
+/** Keep npm native loaders and their adjacent files under Node's package resolution. */
+export function createNativePackages(projectRoot, { isClientSource }) {
+  const discovery = createNativeDiscovery({ projectRoot, isClientSource });
+  const external = new Map();
+  const references = new Map();
+
+  async function ownerOf(file) {
+    // Externalize the outer package for nested node_modules so a transitive addon
+    // remains resolvable from its original npm parent after deployment.
+    const parts = file.split(path.sep);
+    for (let index = 0; index < parts.length - 1; index++) {
+      if (parts[index] !== 'node_modules') continue;
+      const end = index + (parts[index + 1]?.startsWith('@') ? 3 : 2);
+      const candidate = await packageAt(parts.slice(0, end).join(path.sep));
+      if (candidate && contains(candidate.directory, file)) return candidate;
+    }
+    // Workspace packages may resolve through symlinks outside node_modules.
+    for (let directory = path.dirname(file); directory !== path.dirname(directory); directory = path.dirname(directory)) {
+      if (directory === projectRoot) break;
+      const candidate = await packageAt(directory);
+      if (candidate && [...references.keys()].some(entry => contains(directory, entry))) return candidate;
+    }
+  }
+
+  async function discoverOwner(file, mode) {
+    const discovered = await discovery.externalOwner(file, mode);
+    if (!discovered) return;
+    const outer = await ownerOf(file);
+    if (!outer || outer.directory === discovered.directory) return discovered;
+    if (!await discovery.canExternalizeDirectory(outer.directory, mode)) {
+      throw new Error(`Native npm dependency ${discovered.name} is nested inside ${outer.name}, which contains CSS or Client Components. Install ${discovered.name} as a direct application dependency so it can remain external without bypassing ${outer.name}'s compilation.`);
+    }
+    return outer;
+  }
+
+  function ownerFor(file) { return [...external.values()].find(owner => contains(owner.directory, file)); }
+
+  return {
+    get version() { return external.size; },
+    assertCompatibleCss(cssFiles) {
+      for (const css of cssFiles) {
+        const owner = ownerFor(css);
+        if (owner) throw new Error(`Native npm package ${owner.name} also imports CSS (${css}). PRNext cannot yet externalize this mixed package for App Router rendering. Move the native dependency into a separate server-only npm package or a Pages API route.`);
+      }
+    },
+    plugin(mode) {
+      return {
+        name: `prnext-native-packages-${mode}`,
+        setup(esbuild) {
+          esbuild.onResolve({ filter: /\.node$/ }, async args => {
+            if (args.pluginData?.prnextNativeResolving) return;
+            if (mode === 'browser') return { errors: [{ text: `Native Node addon ${args.path} cannot run in a Client Component (${args.importer}). Keep the native dependency in a Server Component or route handler.` }] };
+            const resolved = await esbuild.resolve(args.path, { importer: args.importer, resolveDir: args.resolveDir, kind: args.kind, pluginData: { prnextNativeResolving: true } });
+            if (resolved.errors.length) return resolved;
+            const owner = await ownerOf(resolved.path);
+            if (!owner) return { errors: [{ text: `Local native addon ${args.path} in ${args.importer} cannot be relocated by the App Router compiler. Package the addon and its loader as an npm dependency, then import that package by name.` }] };
+            external.set(owner.directory, owner);
+            return { errors: [{ text: `Native npm package ${owner.name} requires an external server import.` }] };
+          });
+          if (mode === 'browser') return;
+          esbuild.onResolve({ filter: /.*/ }, async args => {
+            if (args.pluginData?.prnextNativeResolving || args.namespace !== 'file') return;
+            if (path.isAbsolute(args.path)) {
+              const reference = references.get(args.path);
+              const owner = ownerFor(args.path) || (reference && await discoverOwner(args.path, mode));
+              if (!owner) return;
+              external.set(owner.directory, owner);
+              if (!reference) return { errors: [{ text: `Native npm package ${owner.name} is imported using a filesystem path (${args.path}). Import its public npm entry by name so the deployed build can resolve its native files.` }] };
+              return { path: reference.specifier, external: true };
+            }
+            if (args.path.startsWith('.') || args.path.startsWith('#')) return;
+            const resolved = await esbuild.resolve(args.path, { importer: args.importer, resolveDir: args.resolveDir, kind: args.kind, pluginData: { prnextNativeResolving: true } });
+            if (resolved.errors.length || resolved.external || resolved.namespace !== 'file') return resolved;
+            references.set(resolved.path, { specifier: args.path, importer: args.importer });
+            const owner = ownerFor(resolved.path) || await discoverOwner(resolved.path, mode);
+            if (owner) {
+              external.set(owner.directory, owner);
+              return { path: args.path, external: true };
+            }
+            return resolved;
+          });
+        },
+      };
+    },
+  };
+}

package/build/npm-packages.mjs

@@ -0,0 +1,110 @@
+import path from 'node:path';
+import { readFile } from 'node:fs/promises';
+import { builtinModules } from 'node:module';
+import { parse } from '@babel/parser';
+import { VISITOR_KEYS } from '@babel/types';
+import { createNativeDiscovery } from './native-discovery.mjs';
+import {frameworkImportPattern} from './framework-imports.mjs';
+
+const builtins = new Set([...builtinModules, ...builtinModules.map(name => 'node:' + name)]);
+const react = /^(?:react|react-dom|react-server-dom-webpack)(?:\/|$)/;
+const framework = name => frameworkImportPattern.test(name) || /^(?:server-only|client-only)$/.test(name);
+const packageName = name => name.startsWith('@') ? name.split('/').slice(0, 2).join('/') : name.split('/')[0];
+const bare = name => !name.startsWith('.') && !name.startsWith('#') && !path.isAbsolute(name);
+
+/** Inspect reached imports once per compiler graph; never execute npm modules. */
+export function npmPackagesPlugin({ pages = false, projectRoot, transpilePackages = [], serverExternalPackages = [] }) {
+  const transpile = new Set(transpilePackages), external = new Set(serverExternalPackages);
+  const sources = new Map(), decisions = new Map();
+  let sourceBytes = 0;
+  const native = createNativeDiscovery({ projectRoot, isClientSource: source => /['"]use (?:client|server)['"]/.test(source) });
+  function imports(file) {
+    if (!sources.has(file)) sources.set(file, (async () => {
+      if (!/\.(?:[cm]?js|jsx|tsx?)$/.test(file)) return { imports: [] };
+      const source = await readFile(file, 'utf8');
+      sourceBytes += Buffer.byteLength(source);
+      if (sourceBytes > 64 * 1024 * 1024) throw new Error('npm compilation analysis exceeded 64 MiB of source. Separate large runtime dependencies using serverExternalPackages.');
+      if (Buffer.byteLength(source) > 8 * 1024 * 1024) throw new Error(`npm source ${file} exceeds the 8 MiB analysis limit. Configure serverExternalPackages for packages that do not use Next APIs.`);
+      const ast = parse(source, { sourceType: 'unambiguous', sourceFilename: file, allowReturnOutsideFunction: true, plugins: ['jsx', ...(/\.tsx?$/.test(file) ? ['typescript'] : [])] });
+      const result = { imports: [], computedRequire: false, frameworkBoundary: ast.program.directives.some(item => ['use client', 'use server'].includes(item.value.value)) };
+      function visit(node) {
+        if (!node || typeof node !== 'object') return;
+        if (['ImportDeclaration', 'ExportNamedDeclaration', 'ExportAllDeclaration'].includes(node.type) && node.source && node.importKind !== 'type' && node.exportKind !== 'type') result.imports.push({ path: node.source.value, kind: 'import-statement' });
+        if (node.type === 'CallExpression' && (node.callee.type === 'Import' || node.callee.type === 'Identifier' && node.callee.name === 'require')) {
+          const argument = node.arguments[0];
+          if (argument?.type === 'StringLiteral') result.imports.push({ path: argument.value, kind: node.callee.type === 'Import' ? 'dynamic-import' : 'require-call' });
+          else if (node.callee.type !== 'Import') result.computedRequire = true;
+        }
+        for (const key of VISITOR_KEYS[node.type] || []) {
+          if (Array.isArray(node[key])) node[key].forEach(visit); else visit(node[key]);
+        }
+      }
+      visit(ast.program);
+      return result;
+    })());
+    return sources.get(file);
+  }
+  return { name: 'prnext-npm-packages', setup(build) {
+    const resolving = { prnextNpmResolving: true, prnextNativeResolving: true };
+    const resolve = (name, importer, kind) => build.resolve(name, { importer, resolveDir: path.dirname(importer), kind, pluginData: resolving });
+    function classify(file) {
+      if (!decisions.has(file)) decisions.set(file, (async () => {
+        const queue = [file], visited = new Set();
+        let directory = path.dirname(file);
+        for (;;) {
+          try { await readFile(path.join(directory, 'package.json')); break; }
+          catch (error) { if (error.code !== 'ENOENT' && error.code !== 'ENOTDIR') throw error; }
+          const parent = path.dirname(directory);
+          if (parent === directory) break;
+          directory = parent;
+        }
+        let needsCompiler = false, computedRequire = false;
+        while (queue.length) {
+          const current = queue.pop();
+          if (visited.has(current)) continue;
+          visited.add(current);
+          if (visited.size > 4096) throw new Error(`npm dependency graph for ${file} exceeds 4096 source files. Use serverExternalPackages for packages that do not use Next APIs.`);
+          const info = await imports(current);
+          needsCompiler ||= info.frameworkBoundary;
+          const relative = path.relative(directory, current);
+          if (!relative.startsWith('..') && !path.isAbsolute(relative) && !relative.split(path.sep).includes('node_modules')) computedRequire ||= info.computedRequire;
+          for (const dependency of info.imports) {
+            if (framework(dependency.path)) { needsCompiler = true; continue; }
+            if (builtins.has(dependency.path) || react.test(dependency.path)) continue;
+            if (bare(dependency.path)) {
+              if (transpile.has(packageName(dependency.path))) needsCompiler = true;
+            }
+            const resolved = await resolve(dependency.path, current, dependency.kind);
+            if (!resolved.errors.length && !resolved.external && resolved.namespace === 'file') queue.push(resolved.path);
+          }
+        }
+        return { needsCompiler, computedRequire };
+      })());
+      return decisions.get(file);
+    }
+    build.onResolve({ filter: /.*/ }, async args => {
+      if (args.pluginData?.prnextNpmResolving || args.namespace !== 'file' || !bare(args.path) || framework(args.path)) return;
+      if (builtins.has(args.path) || react.test(args.path)) return { path: args.path, external: true };
+      const name = packageName(args.path);
+      // App graphs already compile npm by default. Explicit externals need the
+      // same validation as Pages to avoid bypassing compatibility transforms.
+      if (!pages && !external.has(name)) return;
+      const resolved = await resolve(args.path, args.importer || path.join(projectRoot, 'package.json'), args.kind);
+      if (resolved.errors.length || resolved.external || resolved.namespace !== 'file') return resolved;
+      const decision = await classify(resolved.path);
+      const fromRoot = await resolve(args.path, path.join(projectRoot, 'package.json'), args.kind);
+      const nestedResolution = fromRoot.errors.length || fromRoot.path !== resolved.path;
+      const bundle = transpile.has(name) || decision.needsCompiler || nestedResolution;
+      if (external.has(name) && decision.needsCompiler) throw new Error(`serverExternalPackages includes ${name}, but its imports require Next/PRNext compilation. Remove it from serverExternalPackages.`);
+      if (external.has(name) && nestedResolution) throw new Error(`External package ${name} resolves differently from the application root. Install the required version as a direct application dependency.`);
+      if (bundle && !external.has(name)) {
+        const owner = await native.externalOwner(resolved.path, 'ssr');
+        if (owner && decision.needsCompiler) throw new Error(`npm package ${name} combines Next imports with a native addon. Separate the native loader into a server-only dependency so its Next imports can be compiled.`);
+        if (owner) throw new Error(`transpilePackages cannot bundle native npm package ${name}. Keep its native loader external.`);
+        if (decision.computedRequire) throw new Error(`npm package ${name} needs compilation but reaches a computed require(). Use static imports or separate its runtime loader into a serverExternalPackages dependency.`);
+        return resolved;
+      }
+      return { path: args.path, external: true };
+    });
+  } };
+}

package/build/og.mjs

@@ -0,0 +1,14 @@
+import { cp, mkdir, readFile, writeFile } from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+export async function prepareImageResponse(stage) {
+  const directory = path.dirname(createRequire(import.meta.url).resolve('@vercel/og'));
+  const target = path.join(stage, 'runtime/og');
+  await mkdir(target, { recursive: true });
+  await writeFile(path.join(target, 'index.node.mjs'), `import {createRequire as __prnextRequire} from 'node:module';import {fileURLToPath as __prnextFile} from 'node:url';import {dirname as __prnextDir} from 'node:path';const require=__prnextRequire(import.meta.url),__filename=__prnextFile(import.meta.url),__dirname=__prnextDir(__filename);\n` + await readFile(path.join(directory, 'index.node.js'), 'utf8'));
+  for (const name of ['Geist-Regular.ttf', 'resvg.wasm']) await cp(path.join(directory, name), path.join(target, name));
+  await cp(path.join(directory, '../LICENSE'), path.join(target, 'LICENSE'));
+  await writeFile(path.join(target, 'NOTICE.txt'), 'Image renderer: @vercel/og 1.0.3 (https://github.com/vercel/og). PRNext adds Node CommonJS globals to its bundled ESM entry and includes the adjacent HarfBuzz WASM needed by that entry. Upstream bundled notices are preserved in index.node.mjs.\n');
+  const satori = createRequire(path.join(directory, 'index.node.js')).resolve('satori');
+  await cp(createRequire(satori).resolve('harfbuzzjs/hb.wasm'), path.join(target, 'hb.wasm'));
+}

package/build/page-extensions.mjs

@@ -0,0 +1,12 @@
+export const defaultPageExtensions = ['tsx', 'ts', 'jsx', 'js', 'mjs', 'cjs'];
+
+export function pageExtensionPattern(extensions = defaultPageExtensions) {
+  if (!Array.isArray(extensions) || !extensions.length || extensions.length > 64 || extensions.some(value => typeof value !== 'string' || value.length > 100 || !/^[A-Za-z0-9_-]+(?:\.[A-Za-z0-9_-]+)*$/.test(value))) {
+    throw new Error('pageExtensions must be a non-empty array of file suffixes without a leading dot or path separator.');
+  }
+  return new RegExp(`\\.(?:${[...new Set(extensions)].sort((a, b) => b.length - a.length).map(value => value.replaceAll('.', '\\.')).join('|')})$`);
+}
+
+export function validatePageSource(file) {
+  if (!/\.(?:[cm]?js|jsx|tsx?)$/.test(file)) throw new Error(`The pageExtensions entry ${file} requires an unsupported source loader. PRNext currently compiles JavaScript and TypeScript, including compound suffixes such as .page.tsx.`);
+}

package/build/passthrough-loader.cjs

@@ -0,0 +1,4 @@
+module.exports = function(source) {
+  if (Object.keys(this.getOptions()).length) throw new Error('defaultLoaders.babel options require a Babel loader; configure babel-loader explicitly');
+  return source;
+};

package/build/precompress.mjs

@@ -0,0 +1,122 @@
+import { createReadStream, createWriteStream } from 'node:fs';
+import { readdir, rm, stat, utimes, mkdir, copyFile, rename } from 'node:fs/promises';
+import path from 'node:path';
+import { pipeline } from 'node:stream/promises';
+import { createGzip, createGunzip } from 'node:zlib';
+import { createHash, randomUUID } from 'node:crypto';
+
+async function digest(stream, limit = Infinity) {
+  const hash = createHash('sha256');
+  let bytes = 0;
+  for await (const chunk of stream) {
+    bytes += chunk.length;
+    if (bytes > limit) throw Object.assign(new Error('Precompression cache exceeds source size'), { code: 'CACHE_SIZE' });
+    hash.update(chunk);
+  }
+  return hash.digest('hex');
+}
+async function trimCache(directory) {
+  const entries = (await Promise.all((await readdir(directory)).filter(name => /^[a-f0-9]{64}\.gz$/.test(name)).map(async name => {
+    try { return {name, ...await stat(path.join(directory,name))}; } catch(error) { if(error.code==='ENOENT')return null; throw error; }
+  }))).filter(Boolean).sort((a,b)=>b.mtimeMs-a.mtimeMs);
+  let bytes = 0;
+  for (let index=0;index<entries.length;index++) {
+    bytes += entries[index].size;
+    if(index>=512 || bytes>64*1024*1024)await rm(path.join(directory,entries[index].name),{force:true});
+  }
+}
+
+// Images, archives and WOFF fonts already contain compressed data. Only build
+// outputs with useful gzip representations are candidates; public stays mutable.
+const compressibleExtensions = new Set([
+  '.html', '.htm', '.js', '.mjs', '.cjs', '.css', '.json', '.map', '.svg',
+  '.xml', '.txt', '.csv', '.md', '.webmanifest', '.wasm', '.ttf', '.otf', '.eot',
+]);
+
+async function* files(directory, additional) {
+  let entries;
+  try { entries = await readdir(directory, { withFileTypes: true }); }
+  catch (error) { if (error.code === 'ENOENT') return; throw error; }
+  for (const entry of entries) {
+    const filename = path.join(directory, entry.name);
+    if (entry.isDirectory()) yield* files(filename, additional);
+    else if (entry.isFile() && (compressibleExtensions.has(path.extname(entry.name).toLowerCase()) || additional.has(filename))) yield filename;
+  }
+}
+
+async function compress(filename, cacheDirectory) {
+  const original = await stat(filename);
+  if (!original.size) return 'skipped';
+  const sidecar = filename + '.gz';
+  const key = cacheDirectory && original.size <= 64*1024*1024 ? await digest(createReadStream(filename)) : null;
+  const cached = key && path.join(cacheDirectory,key+'.gz');
+  let reused = false;
+  try {
+    if (cached) {
+      try {
+        if ((await stat(cached)).size <= 4*1024*1024) {
+          // Validate cached content, including gzip CRC, using bounded buffers.
+          // A corrupt cache is a miss, never a corrupt published response.
+          const input = createReadStream(cached), unzip = createGunzip();
+          const verified = digest(unzip, original.size);
+          const pumping = pipeline(input,unzip);
+          const [actual] = await Promise.all([verified,pumping]);
+          if (actual === key) { await copyFile(cached,sidecar); reused = true; }
+        }
+      } catch (error) { if (!['ENOENT','ENOTDIR','Z_DATA_ERROR','Z_BUF_ERROR','CACHE_SIZE'].includes(error.code)) throw error; }
+    }
+    if (!reused) await pipeline(createReadStream(filename), createGzip(), createWriteStream(sidecar, { flags: 'wx' }));
+    if ((await stat(sidecar)).size >= original.size) {
+      await rm(sidecar);
+      return 'skipped';
+    }
+    // Node cannot set arbitrary nanosecond timestamps. Use the same conversion
+    // for both immutable outputs so the server's exact freshness check succeeds.
+    const accessed = original.atimeMs / 1000;
+    const modified = original.mtimeMs / 1000;
+    await utimes(filename, accessed, modified);
+    await utimes(sidecar, accessed, modified);
+    if (cached && !reused && (await stat(sidecar)).size <= 4*1024*1024) {
+      await mkdir(cacheDirectory,{recursive:true});
+      const temporary=cached+'.'+randomUUID()+'.tmp';
+      try { await copyFile(sidecar,temporary); await rename(temporary,cached); }
+      finally { await rm(temporary,{force:true}); }
+      await trimCache(cacheDirectory);
+    }
+    return reused ? 'reused' : 'compressed';
+  } catch (error) {
+    await rm(sidecar, { force: true });
+    throw error;
+  }
+}
+
+/** Precompress unpublished build assets with bounded buffers and two workers. */
+export async function precompressBuild(stage, manifest, {cacheDirectory} = {}) {
+  const stats = {compressed:0,reused:0,skipped:0};
+  // Route Handler bodies are opaque bytes. Only consider published, unencoded
+  // response artifacts; the size check also rejects incompressible binary data.
+  const additional = new Set((manifest?.prerendered || []).filter(record =>
+    !record.dataFile && record.file?.endsWith('.body') &&
+    !Object.keys(record.headers || {}).some(name => name.toLowerCase() === 'content-encoding')
+  ).map(record => path.resolve(stage, record.file)));
+  async function* candidates() {
+    yield* files(path.resolve(stage, 'static'), additional);
+    yield* files(path.resolve(stage, 'assets'), additional);
+  }
+  const iterator = candidates();
+  let failure;
+  const worker = async () => {
+    while (!failure) {
+      try {
+        const next = await iterator.next();
+        if (next.done) return;
+        stats[await compress(next.value, cacheDirectory)]++;
+      } catch (error) { failure ||= error; }
+    }
+  };
+  // Wait for both pipelines before reporting failure: the caller can then
+  // discard the staging directory without racing another compressor.
+  await Promise.all([worker(), worker()]);
+  if (failure) throw failure;
+  return stats;
+}