@thomas.f/prnext 0.1.0-alpha.1

package/build/dynamic.mjs

@@ -0,0 +1,125 @@
+import {generateMapped} from './source-maps.mjs';
+import { parse } from '@babel/parser';
+import traverseModule from '@babel/traverse';
+import generateModule from '@babel/generator';
+import * as t from '@babel/types';
+import { createHash } from 'node:crypto';
+import path from 'node:path';
+import { cachedTransform } from './transform-cache.mjs';
+import {frameworkPackages} from './framework-imports.mjs';
+
+const traverse = traverseModule.default || traverseModule;
+const generate = generateModule.default || generateModule;
+const sources = new Set(frameworkPackages.flatMap(name => [`${name}/dynamic`, `${name}/dynamic.js`]));
+
+function importedDynamic(binding) {
+  if (!binding) return false;
+  const declaration = binding.path;
+  if (declaration.isImportDefaultSpecifier() || declaration.isImportNamespaceSpecifier() ||
+      declaration.isImportSpecifier() && (declaration.node.imported.name ?? declaration.node.imported.value) === 'default') {
+    return sources.has(declaration.parentPath.node.source.value);
+  }
+  if (!declaration.isVariableDeclarator()) return false;
+  let value = declaration.node.init;
+  if (t.isMemberExpression(value) && propertyName(value) === 'default') value = value.object;
+  return t.isCallExpression(value) && t.isIdentifier(value.callee, { name: 'require' }) &&
+    !declaration.scope.getBinding('require') && value.arguments.length === 1 &&
+    t.isStringLiteral(value.arguments[0]) && sources.has(value.arguments[0].value);
+}
+
+function propertyName(node) {
+  return !node.computed && t.isIdentifier(node.key ?? node.property)
+    ? (node.key ?? node.property).name : t.isStringLiteral(node.key ?? node.property) ? (node.key ?? node.property).value : undefined;
+}
+
+// A spread after a property may replace it. Only erase a loader when the final
+// ssr value is the literal false; runtime options retain their normal semantics.
+function option(object, name) {
+  if (!object?.isObjectExpression()) return undefined;
+  for (const property of [...object.get('properties')].reverse()) {
+    if (property.isSpreadElement() || propertyName(property.node) === undefined) return undefined;
+    if (propertyName(property.node) !== name) continue;
+    return property.isObjectProperty() ? property.get('value') : name === 'loader' && property.isObjectMethod() ? property : undefined;
+  }
+}
+
+function mayOverride(object, name) {
+  if (!object?.node) return false;
+  if (!object.isObjectExpression()) return true;
+  return object.node.properties.some(property => t.isSpreadElement(property) || propertyName(property) === undefined || propertyName(property) === name);
+}
+
+function loaderBody(loader) {
+  if (!loader?.isIdentifier()) return loader;
+  const binding = loader.scope.getBinding(loader.node.name);
+  if (!binding?.constant) return loader;
+  if (binding.path.isFunctionDeclaration()) return binding.path;
+  const initial = binding.path.isVariableDeclarator() && binding.path.get('init');
+  return initial && (initial.isArrowFunctionExpression() || initial.isFunctionExpression()) ? initial : loader;
+}
+
+/** Add shared hydration IDs without resolving, evaluating or eagerly importing loaders. */
+export function transformDynamicImports(source, filename, { projectRoot, mode = 'browser' } = {}) {
+  if (![...sources].some(name => source.includes(name))) return source;
+  projectRoot ||= process.cwd();
+  return cachedTransform('dynamic',source,[filename,projectRoot,mode],()=>transformDynamicImportsUncached(source,filename,{projectRoot,mode}));
+}
+
+function transformDynamicImportsUncached(source, filename, {projectRoot,mode}) {
+  const ast = parse(source, { sourceType: 'unambiguous', sourceFilename: filename,
+    plugins: ['jsx', ...(/\.tsx?$/.test(filename) ? ['typescript'] : [])] });
+  const relative = path.relative(projectRoot || process.cwd(), filename).replaceAll(path.sep, '/');
+  let changed = false;
+  traverse(ast, {
+    CallExpression(call) {
+      let callee = call.get('callee');
+      if (callee.isMemberExpression() && propertyName(callee.node) === 'default') callee = callee.get('object');
+      if (!callee.isIdentifier() || !importedDynamic(callee.scope.getBinding(callee.node.name))) return;
+      const args = call.get('arguments');
+      if (args.length > 2 || args.some(argument => argument.isSpreadElement())) throw new Error(`next/dynamic accepts a loader and optional options object (${filename}).`);
+      if (!args.length) return;
+      const objectFirst = args[0].isObjectExpression();
+      const firstOptions = objectFirst ? args[0] : undefined;
+      const secondOptions = args[1];
+      let loader = option(secondOptions, 'loader') || option(firstOptions, 'loader') || (!objectFirst ? args[0] : undefined);
+      if (!loader?.node) return;
+      const ssr = option(secondOptions, 'ssr') || (!mayOverride(secondOptions, 'ssr') ? option(firstOptions, 'ssr') : undefined);
+      const noSSR = ssr?.isBooleanLiteral({ value: false });
+      if (noSSR && mode === 'rsc') throw new Error(`ssr: false is not allowed with next/dynamic in an App Server Component (${filename}). Move this dynamic component into a module marked 'use client'.`);
+
+      const imports = new Set();
+      const inspect = node => {
+        const value = t.isImportExpression(node) ? node.source : t.isCallExpression(node) && t.isImport(node.callee) ? node.arguments[0] : undefined;
+        if (!value) return;
+        if (t.isStringLiteral(value)) imports.add(value.value);
+        else if (t.isTemplateLiteral(value) && !value.expressions.length) imports.add(value.quasis[0].value.cooked);
+        else throw new Error(`next/dynamic import paths must be string literals (${filename}).`);
+      };
+      const body = loaderBody(loader);
+      inspect(body.node);
+      body.traverse({ CallExpression(value) { inspect(value.node); }, ImportExpression(value) { inspect(value.node); } });
+      // Custom loaders can return an already available component. They still
+      // need a stable hydration identity even when no import() is present.
+      const keys = imports.size ? [...imports] : [`loader:${generate(body.node, { compact: true, comments: false }).code}`];
+      const ids = keys.map(specifier => 'dynamic-' + createHash('sha256').update(relative + '\0' + specifier).digest('hex').slice(0, 20));
+      const generated = t.objectProperty(t.identifier('loadableGenerated'), t.objectExpression([
+        t.objectProperty(t.identifier('modules'), t.arrayExpression(ids.map(id => t.stringLiteral(id)))),
+      ]));
+
+      if (noSSR && mode !== 'browser') {
+        const empty = t.arrowFunctionExpression([], t.nullLiteral(), true);
+        loader.replaceWith(loader.isObjectMethod() ? t.objectProperty(loader.node.key, empty, loader.node.computed) : empty);
+      }
+      else if (loader.isCallExpression() && (t.isImport(loader.node.callee) || imports.size)) {
+        // The legacy direct import form must not execute at module evaluation.
+        loader.replaceWith(t.arrowFunctionExpression([], loader.node));
+      }
+      const target = secondOptions || firstOptions;
+      if (target?.isObjectExpression()) target.node.properties.push(generated);
+      else if (target?.node) target.replaceWith(t.objectExpression([t.spreadElement(target.node), generated]));
+      else call.node.arguments.push(t.objectExpression([generated]));
+      changed = true;
+    },
+  });
+  return changed ? generateMapped(generate, ast, { comments: true }, source, filename) : source;
+}

package/build/edge.mjs

@@ -0,0 +1,141 @@
+import { readFile, writeFile, mkdir, access } from 'node:fs/promises';
+import {frameworkImportName, frameworkSubpathPattern} from './framework-imports.mjs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { builtinModules, createRequire } from 'node:module';
+import { build } from './compiler.mjs';
+import { parse } from '@babel/parser';
+import traversePackage from '@babel/traverse';
+import { cachedTransform } from './transform-cache.mjs';
+import generatePackage from '@babel/generator';
+import {generateMapped,sourceMapsEnabled,inlineSourceMap,extractSourceMap} from './source-maps.mjs';
+
+const traverse = traversePackage.default || traversePackage;
+const compat = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../compat');
+const builtin = new Set([...builtinModules, ...builtinModules.map(name => 'node:' + name)]);
+const trusted = new Set(['server-primitives.cjs', 'cookies.cjs', 'paths.cjs', 'locale.cjs', 'constants.cjs'].map(name => path.join(compat, name)));
+const names = {
+  headers: ['headers', 'cookies', 'draftMode'],
+  cache: ['revalidateTag', 'revalidatePath', 'unstable_noStore'],
+  navigation: ['redirect', 'permanentRedirect', 'notFound', 'RedirectType', 'unstable_rethrow'],
+};
+
+function validate(source, file, reactMode) {
+  return cachedTransform('edge-validation',source,[file,reactMode],()=>validateUncached(source,file,reactMode));
+}
+function validateUncached(source,file,reactMode) {
+  const ast = parse(source, { sourceType: 'unambiguous', sourceFilename: file, plugins: ['jsx', ...(/\.[cm]?tsx?$/.test(file) ? ['typescript'] : [])] });
+  const edits = [];
+  const fail = message => { throw new Error(`Edge Runtime ${file}: ${message}`); };
+  if (ast.program.directives.some(item => (reactMode === 'ssr' ? ['use server', 'use cache', 'use cache: private', 'use cache: remote'] : ['use client', 'use server', 'use cache', 'use cache: private', 'use cache: remote']).includes(item.value.value))) fail('This React boundary, Server Actions or Cache Components cannot run in the Edge graph.');
+  traverse(ast, {
+    Directive(nodePath) { if (nodePath.node.value.value === 'use server' || nodePath.node.value.value.startsWith('use cache')) fail('Server Actions and Cache Components are not implemented in the Edge graph.'); },
+    UnaryExpression(nodePath) {
+      const { node } = nodePath;
+      if (node.operator === 'typeof' && node.argument.type === 'Identifier' && node.argument.name === 'require' && !nodePath.scope.hasBinding('require')) {
+        edits.push({ start: node.start, end: node.end, text: 'typeof globalThis.require' });
+        node.argument={type:'MemberExpression',object:{type:'Identifier',name:'globalThis'},property:{type:'Identifier',name:'require'},computed:false};
+      }
+    },
+    'CallExpression|OptionalCallExpression|NewExpression'(nodePath) {
+      const node = nodePath.node, callee = node.callee;
+      if (callee.type === 'Identifier' && callee.name === 'require' && !nodePath.scope.hasBinding('require', true)) {
+        if (node.type !== 'CallExpression' || node.arguments.length !== 1 || node.arguments[0]?.type !== 'StringLiteral') fail('dynamic require() is not supported; dependencies must be statically bundled.');
+      } else if (callee.type === 'Identifier' && ['eval', 'Function'].includes(callee.name) && !nodePath.scope.hasBinding(callee.name, true)) fail(`${callee.name}() is not supported; use ESM imports and precompiled JavaScript.`);
+      if (callee.type === 'MemberExpression' && callee.object.type === 'Identifier' && ['globalThis', 'self'].includes(callee.object.name) && ['require', 'eval', 'Function'].includes(callee.computed ? callee.property.value : callee.property.name)) fail('Dynamic JavaScript compilation and require() are not supported.');
+      if (callee.type === 'Import' && node.arguments[0]?.type !== 'StringLiteral') fail('dynamic import paths must be string literals so they can be bundled.');
+      if (callee.type === 'MemberExpression' && callee.object.type === 'Identifier' && callee.object.name === 'WebAssembly' && ['compile', 'compileStreaming', 'Module'].includes(callee.computed ? callee.property.value : callee.property.name)) fail('dynamic WebAssembly compilation is not supported.');
+    },
+    ReferencedIdentifier(nodePath) {
+      const name = nodePath.node.name;
+      if (nodePath.scope.hasBinding(name, true)) return;
+      const parent = nodePath.parent;
+      if (name === 'module' && !(parent.type === 'MemberExpression' && parent.object === nodePath.node && (parent.computed ? parent.property.value : parent.property.name) === 'exports')) fail('Only statically bundled module.exports is supported in Edge; Node module APIs are unavailable.');
+      if (name === 'require' && !(parent.type === 'CallExpression' && parent.callee === nodePath.node && parent.arguments.length === 1 && parent.arguments[0]?.type === 'StringLiteral') && !(parent.type === 'UnaryExpression' && parent.operator === 'typeof')) fail('A runtime require reference is not supported in Edge.');
+    },
+  });
+  if(edits.length && sourceMapsEnabled())return generateMapped(generatePackage.default || generatePackage,ast,{comments:true},source,file);
+  for (const edit of edits.sort((a, b) => b.start - a.start)) source = source.slice(0, edit.start) + edit.text + source.slice(edit.end);
+  return source;
+}
+
+/** Bundle the entire application graph as Web ESM before entering the V8 realm. */
+export async function compileEdge({ file, outfile, projectRoot, dev = false, defineEnvironment = {}, defaultExport = false, reactMode, plugins = [], transformSource }) {
+  const runtime = path.resolve(path.dirname(outfile), '../runtime');
+  await mkdir(runtime, { recursive: true });
+  try { await access(path.join(runtime, 'edge-vm.cjs')); }
+  catch (error) {
+    if (error.code !== 'ENOENT') throw error;
+    await build({ stdin: { contents: "module.exports=require('@edge-runtime/vm')", resolveDir: compat },
+      outfile: path.join(runtime, 'edge-vm.cjs'), bundle: true, platform: 'node', format: 'cjs', target: 'node22', logLevel: 'silent' });
+    const source = await readFile(path.resolve(compat, '../runtime/edge.mjs'), 'utf8');
+    await writeFile(path.join(runtime, 'edge.mjs'), source.replace("import('@edge-runtime/vm')", "import('./edge-vm.cjs')"));
+    const require = createRequire(import.meta.url);
+    // primitives belongs to vm, not to the consumer or PRNext. Resolve it
+    // from its owner so nested npm/pnpm installations keep working.
+    const vmRequire = createRequire(require.resolve('@edge-runtime/vm/package.json'));
+    for (const name of ['vm', 'primitives']) {
+      const directory = path.dirname((name === 'vm' ? require : vmRequire).resolve(`@edge-runtime/${name}/package.json`));
+      await writeFile(path.join(runtime, `edge-${name}.LICENSE.txt`), await readFile(path.join(directory, 'LICENSE.md')));
+    }
+  }
+  const output = await build({ absWorkingDir: projectRoot,
+    stdin: { contents: `import {NextRequest} from 'prnext/server';export const __prnext_createRequest=(url,init)=>new NextRequest(url,init);export * from ${JSON.stringify(file)};${defaultExport ? `export {default} from ${JSON.stringify(file)};` : ''}`, resolveDir: projectRoot, sourcefile: 'prnext-edge-entry.mjs' },
+    write: false, bundle: true, platform: 'browser', format: 'esm', target: 'es2022', jsx: 'automatic', sourcemap:dev?'inline':false, conditions: [...(reactMode === 'rsc' ? ['react-server'] : []), 'edge-light', 'worker', 'browser'],
+    mainFields: ['browser', 'module', 'main'], logLevel: 'silent', metafile: true,
+    define: { 'process.env.NODE_ENV': JSON.stringify(dev ? 'development' : 'production'), ...defineEnvironment, 'process.env.NEXT_RUNTIME': '"edge"' },
+    plugins: [...plugins, { name: 'prnext-edge', setup(builder) {
+      builder.onResolve({ filter: /.*/ }, args => {
+        if (builtin.has(args.path) || args.path.startsWith('node:')) return { errors: [{ text: `Node.js module ${args.path} cannot run in the Edge Runtime (${args.importer}).` }] };
+        if (reactMode && ['react', 'react/jsx-runtime', 'react/jsx-dev-runtime', 'react-dom', 'react-server-dom-webpack/server', 'react-server-dom-webpack/server.node'].includes(args.path)) return { path: args.path, namespace: 'prnext-edge-react' };
+        if (frameworkSubpathPattern.test(args.path)) {
+          const name = frameworkImportName(args.path);
+          if (name === 'server' || Object.hasOwn(names, name)) return { path: name, namespace: 'prnext-edge-compat' };
+          if (name === 'constants') return { path: path.join(compat, 'constants.cjs') };
+          return { errors: [{ text: `Edge Runtime does not support ${args.path}.` }] };
+        }
+        if (args.path === 'server-only') return { path: args.path, namespace: 'prnext-edge-empty' };
+        // The React graph collects styles for the browser. Its recursive resolver
+        // only locates the file; the caller replaces it with an empty/module map
+        // before Edge compilation. Route handlers still reject CSS imports.
+        if (reactMode && args.pluginData?.prnextResolvingCss && /\.(?:css|scss|sass)$/i.test(args.path)) return;
+        if (args.path === 'client-only' || /\.(?:node|css|scss|sass)$/.test(args.path)) return { errors: [{ text: `${args.path} cannot run in the Edge Runtime.` }] };
+      });
+      builder.onLoad({ filter: /.*/, namespace: 'prnext-edge-react' }, args => {
+        const exported = args.path.startsWith('react-server-dom-webpack/server') ? ['registerClientReference', 'registerServerReference'] : Object.keys(createRequire(import.meta.url)(args.path)).filter(name => name !== '__esModule' && name !== 'default');
+        return { loader: 'js', contents: `const module=globalThis.__PRNEXT_EDGE_REACT[${JSON.stringify(args.path === 'react-server-dom-webpack/server.node' ? 'react-server-dom-webpack/server' : args.path)}];export default module;\n` + exported.map(name => `export const ${name}=module[${JSON.stringify(name)}];`).join('\n') };
+      });
+      builder.onLoad({ filter: /.*/, namespace: 'prnext-edge-empty' }, () => ({ contents: '', loader: 'js' }));
+      builder.onLoad({ filter: /.*/, namespace: 'prnext-edge-compat' }, args => ({ loader: 'js', resolveDir: compat, contents: args.path === 'server'
+        ? `import primitives from ${JSON.stringify(path.join(compat, 'server-primitives.cjs'))};export const {NextRequest,NextResponse,NextURL}=primitives;export const connection=globalThis.__PRNEXT_EDGE_HOST.server.connection;`
+        : names[args.path].map(name => `export const ${name}=globalThis.__PRNEXT_EDGE_HOST.${args.path}.${name};`).join('\n') }));
+      builder.onLoad({ filter: /\.[cm]?[jt]sx?$/, namespace: 'file' }, async args => {
+        let source = args.prnextSource ?? await readFile(args.path, 'utf8');
+        if (transformSource) source = await transformSource(source, args.path, builder);
+        if (!trusted.has(args.path)) source = validate(source, args.path, reactMode);
+        return { contents: source, loader: /\.[cm]?tsx?$/.test(args.path) ? 'tsx' : 'jsx', resolveDir: path.dirname(args.path) };
+      });
+    } }] });
+  const mapped=extractSourceMap(output.outputFiles[0].text);
+  const mapFile=output.outputFiles.find(file=>file.path===output.outputFiles[0].path+'.map');
+  let sourceMap=mapped.map || (mapFile?JSON.parse(mapFile.text):undefined);
+  // No outfile is supplied to the bundler: relative sources are rooted at the
+  // project, not at the final server/*.edge.js factory location.
+  if(sourceMap)sourceMap={...sourceMap,sourceRoot:'',sources:sourceMap.sources.map(source=>/^(?:[a-z][a-z+.-]*:|\/)/i.test(source)?source:path.resolve(projectRoot,sourceMap.sourceRoot || '',source))};
+  let code = mapped.code;
+  const ast = parse(code, { sourceType: 'module' }), exported = [];
+  for (const statement of ast.program.body) {
+    if (statement.type === 'ImportDeclaration' || statement.type === 'ExportAllDeclaration') throw new Error('Edge bundle still contains an external import');
+    if (statement.type !== 'ExportNamedDeclaration') continue;
+    if (statement.declaration || statement.source) throw new Error('Unexpected Edge bundle export');
+    for (const specifier of statement.specifiers) exported.push([specifier.exported.name ?? specifier.exported.value, specifier.local.name]);
+  }
+  // esbuild emits only final named exports. Removing them preserves top-level
+  // await inside an async factory without requiring Node's experimental modules.
+  for (const statement of [...ast.program.body].reverse()) if (statement.type === 'ExportNamedDeclaration') code = code.slice(0, statement.start) + code.slice(statement.start,statement.end).replace(/[^\r\n]/g,' ') + code.slice(statement.end);
+  const asset = outfile.replace(/\.mjs$/, '.edge.js');
+  await mkdir(path.dirname(outfile), { recursive: true });
+  await writeFile(asset, inlineSourceMap(`(async()=>{\n${code}\nreturn {${exported.map(([name, local]) => `${JSON.stringify(name)}:${local}`).join(',')}};})()`,sourceMap?{...sourceMap,mappings:';'+sourceMap.mappings}:undefined));
+  await writeFile(outfile, `import {readFile} from 'node:fs/promises';import {loadEdgeModule} from '../runtime/edge.mjs';const edge=await loadEdgeModule(await readFile(new URL(${JSON.stringify('./' + path.basename(asset))},import.meta.url),'utf8'),import.meta.url,${JSON.stringify(reactMode)});\n${exported.filter(([name]) => name !== '__prnext_createRequest').map(([name], index) => `const binding${index}=edge[${JSON.stringify(name)}];export {binding${index} as ${JSON.stringify(name)}};`).join('\n')}`);
+  return { exports: exported.map(([name]) => name), metafile: output.metafile };
+}

package/build/font-data.LICENSE.txt

@@ -0,0 +1,25 @@
+Google font metadata snapshot from Next.js 16.3.5
+Source: next/dist/compiled/@next/font/dist/google/font-data.json
+Only family names, supported variants, axes, and subsets are included; no font binaries.
+
+The MIT License (MIT)
+
+Copyright (c) 2025 Vercel, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.