@thomas.f/prnext 0.1.0-alpha.1

package/runtime/cache-components-rsc.mjs

@@ -0,0 +1,64 @@
+import { renderToReadableStream, decodeReply, createTemporaryReferenceSet as serverReferences, registerClientReference } from 'react-server-dom-webpack/server.node';
+import { encodeReply, createTemporaryReferenceSet as clientReferences, createFromReadableStream } from 'react-server-dom-webpack/client.edge';
+import { actionManifest, registerCacheClientModule } from './action-server.mjs';
+import { codecSymbol } from '../compat/use-cache.cjs';
+import { encodeCacheArguments } from './cache-arguments.mjs';
+import { flightBundler } from './worker-metadata.mjs';
+const consumers = new WeakMap();
+const emptyModules = Object.freeze({});
+
+export function flightConsumer(context) {
+  const clientModules = context.clientModules || emptyModules;
+  let moduleMap = consumers.get(clientModules);
+  if (!moduleMap) {
+    moduleMap = Object.create(null);
+    for (const id of Object.keys(clientModules)) {
+      const cacheId = 'prnext-cache-client:' + id;
+      const values = new Map();
+      const namespace = new Proxy(Object.create(null), {
+        get(_target, name) {
+          if (typeof name !== 'string' || name === 'then') return;
+          if (!values.has(name)) values.set(name, registerClientReference(function () { throw new Error('Cannot invoke a Client Component inside a cached Server Component'); }, id, name));
+          return values.get(name);
+        },
+        getOwnPropertyDescriptor(_target, name) { if (typeof name === 'string' && name !== 'then') return { configurable: true, enumerable: true }; },
+      });
+      registerCacheClientModule(cacheId, namespace);
+      moduleMap[id] = { '*': { id: cacheId, chunks: [], name: '*' } };
+    }
+    consumers.set(clientModules, moduleMap);
+  }
+  return { moduleMap, moduleLoading: null, serverModuleMap: actionManifest(context) };
+}
+
+globalThis[codecSymbol] = {
+  async arguments(values, context) {
+    const temporaryReferences = clientReferences();
+    const body = await encodeReply(values, { temporaryReferences, signal: context.signal });
+    const key = await encodeCacheArguments(body);
+    const serverTemporaryReferences = serverReferences();
+    const decoded = await decodeReply(body, actionManifest(context), { temporaryReferences: serverTemporaryReferences, arraySizeLimit: 10000 });
+    return { key, values: decoded, temporaryReferences, serverTemporaryReferences };
+  },
+  async render(callback, encoded, context) {
+    const bundler = flightBundler(context.clientModules, false);
+    let failure;
+    // React calls then inside its rendering context, preserving React.cache isolation.
+    const result = { then(resolve, reject) { Promise.resolve().then(callback).then(resolve, reject); } };
+    const stream = renderToReadableStream(result, bundler, { signal: context.signal, temporaryReferences: encoded.serverTemporaryReferences, onError(error) { failure ||= error; return 'PRNextCacheRenderError'; } });
+    const chunks = [];
+    let size = 0;
+    for await (const value of stream) {
+      size += value.byteLength;
+      if (size > 16 * 1024 * 1024) throw new Error('Cached React result exceeds the 16 MiB rendering limit');
+      chunks.push(Buffer.from(value));
+    }
+    if (failure) throw failure;
+    return Buffer.concat(chunks, size);
+  },
+  async decode(bytes, encoded, context) {
+    return createFromReadableStream(new ReadableStream({ start(controller) { controller.enqueue(bytes); controller.close(); } }), {
+      serverConsumerManifest: flightConsumer(context), temporaryReferences: encoded.temporaryReferences, replayConsoleLogs: false,
+    });
+  },
+};

package/runtime/cache-request.mjs

@@ -0,0 +1,23 @@
+import { runRequestContext, currentRequest } from '../compat/headers.cjs';
+import { flushCacheInvalidations, flushCacheWork } from '../compat/data-cache.cjs';
+
+// Keep background fills alive until the transport has sent the response. In
+// particular, serving stale data must not wait for its replacement to finish.
+export function withCacheRequest(options, phase, callback) {
+  // Raw upload bytes belong to the IncomingMessage/Request. Async cache work
+  // only needs metadata, and may survive the response for stale revalidation.
+  return runRequestContext({ ...options, body: undefined, routePattern: options.route?.pattern, cacheConfig: options.route?.cacheConfig, phase }, async () => {
+    const context = currentRequest();
+    try {
+      const response = await callback(context);
+      await flushCacheInvalidations(context);
+      context.cacheState.closed = true;
+      return { ...response,
+        ...(context.draftMode || context.draftChanged ? { headers: { ...response.headers, 'cache-control': 'private, no-cache, no-store, max-age=0' } } : {}),
+        finalizeCache: () => flushCacheWork(context) };
+    } catch (error) {
+      await flushCacheWork(context);
+      throw error;
+    }
+  });
+}

package/runtime/client-navigation.mjs

@@ -0,0 +1,40 @@
+import { addBasePath, removeBasePath, hasBasePath, normalizeTrailingSlash } from '../compat/paths.cjs';
+
+function httpURL(value, base) {
+  const target = new URL(value, base);
+  if (!['http:', 'https:'].includes(target.protocol)) throw new Error('Unsupported navigation protocol');
+  return target;
+}
+
+/** User router hrefs are logical; URL objects and absolute URLs are already public. */
+export function publicNavigationURL(value, visibleURL, basePath = '', policy = {}) {
+  if (value instanceof URL || /^(?:[a-z][a-z\d+.-]*:|\/\/)/i.test(value)) return httpURL(value, visibleURL);
+  const internal = httpURL(visibleURL);
+  internal.pathname = removeBasePath(internal.pathname, basePath);
+  const target = httpURL(value, internal);
+  target.pathname = addBasePath(target.pathname, basePath);
+  if (basePath && target.pathname === `${basePath}/` && !policy.trailingSlash && !policy.skipTrailingSlashRedirect) target.pathname = basePath;
+  target.pathname = normalizeTrailingSlash(target.pathname, policy);
+  return target;
+}
+
+export function isApplicationURL(target, origin, basePath = '') {
+  return target.origin === origin && hasBasePath(target.pathname, basePath);
+}
+
+/** A document redirect may leave the site; Flight must stay on this origin. */
+export function flightResponseURL(response, requested) {
+  const source = httpURL(requested);
+  const target = httpURL(response.url || source.href, source);
+  if (target.origin !== source.origin) throw new Error('Cross-origin navigation requires a document request');
+  // Fetch omits the request fragment. Keep it unless a final URL supplies one.
+  if (!target.hash) target.hash = source.hash;
+  return target;
+}
+
+/** Data redirects carry a public destination instead of a fetch-follow Location. */
+export function pageDataRedirectURL(response, visibleURL) {
+  const target = response.headers.get('x-nextjs-redirect') ||
+    ([301, 302, 303, 307, 308].includes(response.status) ? response.headers.get('location') : null);
+  return target === null ? null : httpURL(target, visibleURL);
+}

package/runtime/dev-client.mjs

@@ -0,0 +1,129 @@
+import Refresh from 'react-refresh/runtime';
+
+const state = globalThis.__PRNEXT_DEV__ ||= {
+  applications: new Map(), modules: new Map(), buildId: null, manifest: null,
+  pending: null, applying: false, unsafe: false, queued: null, source: null,
+};
+if (!state.injected) { Refresh.injectIntoGlobalHook(globalThis); state.injected = true; }
+export const register = (type, id) => Refresh.register(type, id);
+export const signature = () => Refresh.createSignatureFunctionForTransform();
+export function registerModule(id, hash, boundary) {
+  const previous = state.modules.get(id);
+  if (previous && previous.hash !== hash && (!previous.boundary || !boundary)) state.unsafe = true;
+  state.modules.set(id, { hash, boundary });
+}
+
+function clearError() { document.getElementById('__prnext_dev_error__')?.remove(); state.overlayError = undefined; }
+function errorKey(error) {
+  return typeof error?.digest === 'string' ? `${error.digest.slice(0, 256)}:${String(error.message || '').slice(0, 512)}` : null;
+}
+function showError(error) {
+  const key = errorKey(error);
+  if (error && typeof error === 'object' && (state.dismissedErrors?.has(error) || (key && state.dismissedDigests?.has(key)))) return;
+  state.overlayError = error;
+  let host = document.getElementById('__prnext_dev_error__');
+  if (!host) {
+    host = document.createElement('div'); host.id = '__prnext_dev_error__';
+    Object.assign(host.style, { position: 'fixed', inset: '0', zIndex: '2147483647' });
+    const shadow = host.attachShadow({ mode: 'open' });
+    const style = document.createElement('style');
+    style.textContent = ':host{color-scheme:dark}section{box-sizing:border-box;overflow:auto;height:100%;padding:32px;background:#17191fee;color:#f4f5f7;font:14px/1.6 ui-monospace,monospace}h1{font:600 22px system-ui;color:#ff7474}pre{white-space:pre-wrap;overflow-wrap:anywhere}button{position:fixed;right:24px;top:24px;padding:8px 14px;border:1px solid #697080;border-radius:6px;background:#292e39;color:white;cursor:pointer}';
+    const section = document.createElement('section'); section.setAttribute('role', 'alertdialog'); section.setAttribute('aria-label', 'PRNext development error');
+    const heading = document.createElement('h1'); heading.textContent = 'PRNext — development error';
+    const close = document.createElement('button'); close.textContent = 'Dismiss'; close.onclick = () => {
+      // React may report the same failed model again while its boundary retries.
+      // Closing that diagnostic must not block the recovered application.
+      if (state.overlayError && typeof state.overlayError === 'object') (state.dismissedErrors ||= new WeakSet()).add(state.overlayError);
+      const key = errorKey(state.overlayError);
+      if (key) {
+        const entries = state.dismissedDigests ||= new Set();
+        if (entries.size >= 32) entries.delete(entries.values().next().value);
+        entries.add(key);
+      }
+      clearError();
+    };
+    const details = document.createElement('pre'); details.id = 'details';
+    section.append(heading, close, details); shadow.append(style, section); document.documentElement.append(host);
+  }
+  host.shadowRoot.getElementById('details').textContent = String(error?.stack || error?.message || error).slice(0, 48 * 1024);
+}
+
+async function updateStyles(urls) {
+  const wanted = new Set(urls.map(url => new URL(url, location.href).href));
+  const old = [...document.querySelectorAll('link[rel="stylesheet"]')].filter(link => link.href.includes('/_prnext/assets/'));
+  const existing = new Set(old.map(link => link.href));
+  await Promise.all([...wanted].filter(href => !existing.has(href)).map(href => new Promise((resolve, reject) => {
+    const link = document.createElement('link'); link.rel = 'stylesheet'; link.href = href;
+    const timer = setTimeout(() => { link.remove(); reject(new Error('Stylesheet update timed out')); }, 15_000);
+    link.onload = () => { clearTimeout(timer); resolve(); };
+    link.onerror = () => { clearTimeout(timer); link.remove(); reject(new Error(`Could not load updated stylesheet ${href}`)); };
+    document.head.append(link);
+  })));
+  for (const link of old) if (!wanted.has(link.href)) link.remove();
+}
+
+async function applyUpdate(message) {
+  if (state.applying) { state.queued = message; return; }
+  if (!message.clientManifest) { location.reload(); return; }
+  const changed = message.changed || [];
+  if (changed.some(file => /(?:^|\/)(?:(?:next|prnext)\.config\.|package(?:-lock)?\.json|\.env|pages\/_document\.)/.test(file))) { location.reload(); return; }
+  state.applying = true; state.unsafe = false; state.pending = null;
+  state.dismissedErrors = new WeakSet();
+  state.dismissedDigests = new Set();
+  try {
+    const response = await fetch(message.clientManifest, { cache: 'no-store', credentials: 'same-origin' });
+    if (!response.ok) throw new Error(`Development manifest failed (${response.status})`);
+    const manifest = await response.json();
+    if (manifest.buildId !== message.buildId) throw new Error('Development build changed during refresh');
+    const kind = state.currentKind;
+    const application = await state.applications.get(kind);
+    const route = kind === 'pages' ? manifest.pages.find(route => route.pattern === application.router.snapshot().pathname) : null;
+    const entry = kind === 'pages' ? route?.client : manifest.app?.client;
+    if (!entry) { location.reload(); return; }
+    await import(/* webpackIgnore: true */ entry);
+    const pending = state.pending;
+    if (pending) await application.devPrepare?.(pending.options);
+    if (state.unsafe) { location.reload(); return; }
+    await updateStyles(kind === 'pages' ? route.css : manifest.app.css);
+    clearError();
+    Refresh.performReactRefresh();
+    if (pending) await application.devCommit?.(pending.options);
+    state.buildId = message.buildId;
+    state.manifest = manifest;
+    document.documentElement.dataset.prnextDevBuild = message.buildId;
+    globalThis.dispatchEvent(new CustomEvent('prnext:refresh', { detail: { buildId: message.buildId } }));
+  } catch (error) { showError(error); }
+  finally {
+    state.applying = false; state.pending = null;
+    if (state.queued) { const queued = state.queued; state.queued = null; if (queued.buildId !== state.buildId) void applyUpdate(queued); }
+  }
+}
+
+function connect(options) {
+  if (state.source) return;
+  state.buildId = options.dev.buildId;
+  const source = new EventSource(`${options.basePath || ''}/_prnext/dev`);
+  state.source = source;
+  source.onmessage = event => {
+    let message; try { message = JSON.parse(event.data); } catch { return; }
+    if (message.state === 'error') { showError(message.error || 'Build failed'); return; }
+    if (message.state !== 'ready') return;
+    if (message.buildId === state.buildId) return;
+    void applyUpdate(message);
+  };
+  globalThis.addEventListener('error', event => { if (event.error) showError(event.error); });
+  globalThis.addEventListener('unhandledrejection', event => showError(event.reason));
+  globalThis.addEventListener('pagehide', () => source.close(), { once: true });
+}
+
+state.reportError = showError;
+state.bootstrap = (kind, options, start) => {
+  state.currentKind = kind;
+  if (!state.applications.has(kind)) {
+    const application = Promise.resolve().then(start);
+    state.applications.set(kind, application);
+    connect(options);
+    application.catch(showError);
+  } else if (state.applying) state.pending = { kind, options };
+  return state.applications.get(kind);
+};

package/runtime/dev-file-changes.mjs

@@ -0,0 +1,110 @@
+import path from 'node:path';
+import {createHash} from 'node:crypto';
+import {createReadStream} from 'node:fs';
+import {stat, readdir} from 'node:fs/promises';
+import {shouldWatchProjectFile} from './env.mjs';
+
+function directoryFingerprint(entries) {
+  const hash=createHash('sha256');
+  for (const entry of entries.sort((a,b)=>a.name.localeCompare(b.name))) hash.update(`${entry.isDirectory()?'d':entry.isSymbolicLink()?'l':'f'}:${entry.name}\0`);
+  return 'directory:'+hash.digest('hex');
+}
+
+// Remember the bytes actually consumed by webpack, not the file's contents at
+// the end of a build: an edit made after a read must still trigger a rebuild.
+export function createDevInputSnapshot(roots, {maxEntries=512,maxBytes=1024*1024}={}) {
+  const inputs=new Map();
+  let bytes=0;
+  function remember(relative,value) {
+    if (inputs.has(relative)) {
+      if (inputs.get(relative)!==value) inputs.set(relative,null);
+      return;
+    }
+    const size=relative.length*2+value.length*2+64;
+    if (inputs.size>=maxEntries || bytes+size>maxBytes) return;
+    inputs.set(relative,value);bytes+=size;
+  }
+  return {
+    record(file, source) {
+      const root=roots.find(root=>file.startsWith(root+path.sep));
+      if (!root) return;
+      const relative=path.relative(root,file).replaceAll(path.sep,'/');
+      if (!shouldWatchProjectFile(relative)) return;
+      const value='file:'+createHash('sha256').update(source).digest('hex');
+      // Different targets consuming different bytes cannot acknowledge this
+      // event, even when the file is changed back before compilation ends.
+      remember(relative,value);
+    },
+    async captureDirectory(relative) {
+      // Called after an awaited content generator and before graph resolution.
+      // Include its types/aggregate indexes, which may not be runtime imports.
+      if (!shouldWatchProjectFile(relative) || inputs.size>=maxEntries || bytes>=maxBytes) return;
+      const file=path.join(roots[0],relative);
+      let entries;
+      try {entries=await readdir(file,{withFileTypes:true});}
+      catch(error){if(error.code==='ENOENT')return;throw error;}
+      remember(relative,directoryFingerprint(entries));
+      for(const entry of entries) {
+        if(inputs.size>=maxEntries || bytes>=maxBytes)break;
+        const child=relative+'/'+entry.name;
+        if(!shouldWatchProjectFile(child))continue;
+        if(entry.isDirectory())await this.captureDirectory(child);
+        else if(entry.isFile()) {
+          const hash=createHash('sha256');
+          try {
+            for await(const chunk of createReadStream(path.join(file,entry.name),{highWaterMark:64*1024}))hash.update(chunk);
+            remember(child,'file:'+hash.digest('hex'));
+          } catch(error) {if(error.code!=='ENOENT')throw error;}
+        }
+      }
+    },
+    entries:()=>[...inputs],
+  };
+}
+
+// Generators may rewrite identical JSON/modules on every compilation. Retain
+// only bounded path/digest pairs, never file contents or full directory lists.
+export function createDevChangeFilter(root, {maxEntries=512,maxBytes=1024*1024}={}) {
+  const fingerprints=new Map();
+  let bytes=0;
+  function remember(file,value) {
+    const previous=fingerprints.get(file);
+    if (previous) {fingerprints.delete(file);bytes-=previous.size;}
+    if (value==null) return;
+    const size=file.length*2+value.length*2+64;
+    if (size>maxBytes || maxEntries<1) return;
+    while(fingerprints.size>=maxEntries || bytes+size>maxBytes) {
+      const [key,oldest]=fingerprints.entries().next().value;
+      fingerprints.delete(key);bytes-=oldest.size;
+    }
+    fingerprints.set(file,{value,size});bytes+=size;
+  }
+  async function fingerprint(relative) {
+    const file=path.join(root,relative), hash=createHash('sha256');
+    try {
+      const info=await stat(file);
+      if (info.isDirectory()) {
+        const entries=await readdir(file,{withFileTypes:true});
+        return directoryFingerprint(entries);
+      }
+      if (!info.isFile()) return `special:${info.mode}:${info.mtimeMs}`;
+      for await (const chunk of createReadStream(file,{highWaterMark:64*1024})) hash.update(chunk);
+      return 'file:'+hash.digest('hex');
+    } catch (error) {
+      if (error.code==='ENOENT' || error.code==='ENOTDIR') return 'missing';
+      // An unreadable/changing file must still trigger the compiler diagnostic.
+      return undefined;
+    }
+  }
+  const filter=async files => {
+    const changed=[];
+    for (const file of files) {
+      const value=await fingerprint(file), previous=fingerprints.get(file);
+      if (value===undefined || !previous || previous.value!==value) changed.push(file);
+      remember(file,value);
+    }
+    return changed;
+  };
+  filter.acceptInputs=inputs=>{for(const [file,value] of inputs)remember(file,value);};
+  return filter;
+}

package/runtime/document.mjs

@@ -0,0 +1,96 @@
+import React from 'react';
+import DefaultDocument, { DocumentContext } from '../compat/document.cjs';
+import DefaultApp from '../compat/app.cjs';
+import { RouterProvider, useRouter } from '../compat/router.cjs';
+import { HeadProvider, dedupeHead } from '../compat/head.cjs';
+import { DynamicProvider, preloadAll } from '../compat/dynamic.cjs';
+import { MAX_RESPONSE_BYTES } from './http.mjs';
+import { ScriptContext } from '../compat/script-context.cjs';
+import { completePageScripts } from './script-html.mjs';
+
+function PageEntry({ App, Component, pageProps, appProps }) {
+  const router = useRouter();
+  return React.createElement(App, { ...appProps, Component, pageProps, router });
+}
+function defaultHead() {
+  return [React.createElement('meta', { charSet: 'utf-8' }),
+    React.createElement('meta', { name: 'viewport', content: 'width=device-width' })];
+}
+
+export async function renderDocument({ Document = DefaultDocument, App = DefaultApp, Page, props, appProps = {}, snapshot, route,
+  request, response, error, production, buildId, manifest, isStatic, hasServerProps, hasPageInitialProps, hasAppInitialProps }) {
+  if (typeof Document !== 'function' && (!Document || typeof Document !== 'object')) throw new TypeError('pages/_document must export a React component as default');
+  const { renderToString, renderToStaticMarkup } = await import('react-dom/server');
+  await preloadAll();
+  const dynamicModules = new Set();
+  const pageScripts = [], documentScripts = [];
+  const scriptContext = { appDir: false, ssr: true, document: false, collect: props => pageScripts.push(props) };
+  let renderedHead = defaultHead();
+  const tree = (EnhancedApp, EnhancedPage, pageProps, collector, appProps) =>
+    React.createElement(manifest?.config?.reactStrictMode ? React.StrictMode : React.Fragment, null, React.createElement(RouterProvider, { router: snapshot }, React.createElement(HeadProvider, { collector },
+      React.createElement(DynamicProvider, { modules: dynamicModules },
+        React.createElement(ScriptContext.Provider, { value: scriptContext },
+          React.createElement(PageEntry, { App: EnhancedApp, Component: EnhancedPage, pageProps, appProps }))))));
+  const renderPage = async (options = {}) => {
+    if (typeof options === 'function') options = { enhanceComponent: options };
+    if (!options || typeof options !== 'object') throw new TypeError('Document renderPage expects component enhancers');
+    const EnhancedApp = options.enhanceApp ? options.enhanceApp(App) : App;
+    const EnhancedPage = options.enhanceComponent ? options.enhanceComponent(Page) : Page;
+    await preloadAll();
+    pageScripts.length = 0;
+    const collector = [];
+    const html = `<div id="__prnext">${renderToString(tree(EnhancedApp, EnhancedPage, props, collector, appProps))}</div>`;
+    if (Buffer.byteLength(html) > MAX_RESPONSE_BYTES) throw new Error('Response exceeds the 16 MiB PRNext limit');
+    renderedHead = dedupeHead([...defaultHead(), ...collector]);
+    return { html, head: renderedHead };
+  };
+  const AppTree = ({ pageProps = {}, ...appProps }) => tree(App, Page, pageProps, [], appProps);
+  const builtinError = route.internal && route.errorStatus;
+  const autoStatic = !builtinError && !isStatic && !hasServerProps && !hasPageInitialProps && !hasAppInitialProps;
+  const autoAsPath = snapshot.pathname + (request.url.endsWith('/') && !snapshot.pathname.endsWith('/') && !snapshot.pathname.includes('[') ? '/' : '');
+  const documentAsPath = builtinError ? `/${route.errorStatus}` : autoStatic ? autoAsPath : snapshot.asPath;
+  const context = { err: error, req: autoStatic ? undefined : request, res: autoStatic ? undefined : response, pathname: snapshot.pathname,
+    query: autoStatic ? {} : snapshot.query, asPath: documentAsPath, AppTree, renderPage,
+    async defaultGetInitialProps(ctx) {
+      const result = await ctx.renderPage({ enhanceApp: Component => Component });
+      return { html: result.html, head: result.head, styles: [] };
+    } };
+  let initial;
+  const hasInitialProps = typeof Document.getInitialProps === 'function';
+  if (hasInitialProps) initial = await Document.getInitialProps(context);
+  else initial = { ...await renderPage(), styles: [] };
+  if (response.writableEnded) return { ended: true };
+  if (!initial || typeof initial !== 'object' || Array.isArray(initial) || typeof initial.html !== 'string') {
+    throw new TypeError('Document.getInitialProps must return an object with an html string');
+  }
+  if (Buffer.byteLength(initial.html) > MAX_RESPONSE_BYTES) throw new Error('Response exceeds the 16 MiB PRNext limit');
+  const payload = { props, appProps, router: snapshot, buildId, route: { pattern: snapshot.pathname }, dynamicIds: [...dynamicModules] };
+  const assetPrefix = manifest?.config?.assetPrefix || manifest?.config?.basePath || '';
+  const nextData = { props: { ...appProps, pageProps: props }, page: snapshot.pathname, query: snapshot.query, buildId,
+    ...(snapshot.locale ? {locale:snapshot.locale,locales:snapshot.locales,defaultLocale:snapshot.defaultLocale} : {}),
+    ...(assetPrefix ? { assetPrefix } : {}),
+    isFallback: snapshot.isFallback, ...(isStatic ? { gsp: true } : {}), ...(hasServerProps ? { gssp: true } : {}),
+    ...(hasPageInitialProps ? { gip: true } : {}), ...(hasAppInitialProps ? { appGip: true } : {}) };
+  const head = React.Children.toArray(initial.head).map((element, key) => React.isValidElement(element)
+    ? React.cloneElement(element, { key, 'data-prnext-head': '' }) : element);
+  const state = { html: initial.html, head, styles: initial.styles, rendered: new Set(), payload,
+    client: route.client, css: route.css || [], fonts: route.fonts || [], __NEXT_DATA__: nextData };
+  const documentProps = { __NEXT_DATA__: nextData, assetPrefix,
+    dangerousAsPath: documentAsPath, isDevelopment: !production, ...initial };
+  if (!hasInitialProps) delete documentProps.html;
+  state.nonce = documentProps.nonce;
+  state.crossOrigin = documentProps.crossOrigin;
+  let markup = renderToStaticMarkup(React.createElement(DocumentContext.Provider, { value: state },
+    React.createElement(ScriptContext.Provider, { value: { ...scriptContext, document: true, collect: props => documentScripts.push(props) } },
+      React.createElement(Document, documentProps))))
+    .replace('<prnext-document-body-target></prnext-document-body-target>', () => initial.html);
+  markup = completePageScripts(markup, { pageScripts, documentScripts, worker: manifest?.scriptWorkers,
+    nonce: state.headNonce || state.nonce, crossOrigin: state.headCrossOrigin || state.crossOrigin }, renderToStaticMarkup);
+  if (!production) {
+    const missing = ['Html', 'Head', 'Main', 'NextScript'].filter(name => !state.rendered.has(name));
+    if (missing.length) console.warn(`Your custom Document did not render the required components: ${missing.map(name => `<${name} />`).join(', ')}`);
+  }
+  const html = /^<!doctype html>/i.test(markup) ? markup : `<!DOCTYPE html>${markup}`;
+  if (Buffer.byteLength(html) > MAX_RESPONSE_BYTES) throw new Error('Response exceeds the 16 MiB PRNext limit');
+  return { html };
+}

package/runtime/edge.mjs

@@ -0,0 +1,105 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { runInContext } from 'node:vm';
+import { createRequire } from 'node:module';
+import * as headerApi from '../compat/headers.cjs';
+import * as cacheApi from '../compat/cache.cjs';
+import * as navigationApi from '../compat/navigation-server.cjs';
+import { connection } from '../compat/server.cjs';
+
+function responseHeaders(headers) {
+  const values = [...headers].filter(([name]) => name.toLowerCase() !== 'set-cookie');
+  for (const cookie of headers.getSetCookie()) values.push(['set-cookie', cookie]);
+  return values;
+}
+
+function responseMetadata(target, source) {
+  const metadata = { url: source.url, redirected: source.redirected, type: source.type };
+  const clone = target.clone;
+  Object.defineProperties(target, {
+    ...Object.fromEntries(Object.entries(metadata).map(([name, value]) => [name, { value, configurable: true }])),
+    clone: { configurable: true, value() { return responseMetadata(Reflect.apply(clone, this, []), metadata); } },
+  });
+  return target;
+}
+
+const reactVMs = new Map();
+
+async function createEdgeVM(reactMode) {
+  const vendor = await import('@edge-runtime/vm');
+  const { EdgeVM } = vendor.default || vendor;
+  const react = {}, framework = {};
+  if (reactMode) {
+    const require = createRequire(import.meta.url);
+    for (const name of ['react', 'react/jsx-runtime', 'react/jsx-dev-runtime', 'react-dom']) react[name] = require(name);
+    if (reactMode === 'rsc') react['react-server-dom-webpack/server'] = Object.fromEntries(['registerClientReference', 'registerServerReference'].map(name => [name, require('react-server-dom-webpack/server.node')[name]]));
+    if (reactMode === 'rsc') framework['app-dynamic'] = require('../compat/app-dynamic.cjs');
+    if (reactMode === 'ssr') for (const name of ['link', 'image', 'head', 'router', 'compat-router', 'next-router-context', 'next-app-router-context', 'navigation', 'script', 'app-context', 'app-layout-context', 'app-navigation-boundary', 'app-client-page', 'app-error-boundary', 'app-dynamic']) framework[name] = require('../compat/' + name + '.cjs');
+  }
+  const actionHelpers = reactMode ? { 'action-crypto': await import('./action-crypto.mjs'), 'action-ssr': await import('./action-ssr.mjs') } : {};
+  return new EdgeVM({ codeGeneration: { strings: false, wasm: false }, extend(context) {
+    context.process = { env: { ...process.env, NEXT_RUNTIME: 'edge' } };
+    context.AsyncLocalStorage = AsyncLocalStorage;
+    if (reactMode) {
+      context.__PRNEXT_EDGE_REACT = react;
+      context.__PRNEXT_EDGE_ACTIONS = actionHelpers;
+      context.__PRNEXT_EDGE_FRAMEWORK = framework;
+      // React's host Flight serializer recognizes these Web value types by
+      // constructor identity; keep their semantics across the two realms.
+      Object.assign(context, { Date, Map, Set, FormData, ArrayBuffer, Uint8Array, Uint8ClampedArray, Int8Array, Uint16Array, Int16Array, Uint32Array, Int32Array, Float32Array, Float64Array, BigInt64Array, BigUint64Array, DataView,
+        Error, TypeError, RangeError, ReferenceError, SyntaxError, URIError, EvalError, AggregateError });
+    }
+    context.__PRNEXT_EDGE_HOST = {
+      headers: { headers: async () => {
+        const values = new context.Headers(await headerApi.headers());
+        return new Proxy(values, { get(target, key) {
+          if (['set', 'append', 'delete'].includes(key)) return () => { throw new Error('Headers cannot be modified'); };
+          const value = Reflect.get(target, key, target);
+          return typeof value === 'function' ? value.bind(target) : value;
+        } });
+      }, cookies: headerApi.cookies, draftMode: headerApi.draftMode },
+      cache: { revalidateTag: cacheApi.revalidateTag, revalidatePath: cacheApi.revalidatePath, unstable_noStore: cacheApi.unstable_noStore },
+      navigation: { redirect: navigationApi.redirect, permanentRedirect: navigationApi.permanentRedirect,
+        notFound: navigationApi.notFound, RedirectType: navigationApi.RedirectType, unstable_rethrow: navigationApi.unstable_rethrow },
+      server: { connection },
+    };
+    context.fetch = async (input, init) => {
+      if (input instanceof context.Request) input = new Request(input.url, { method: input.method, headers: [...input.headers], body: input.body, signal: input.signal, duplex: 'half',
+        cache: input.cache, credentials: input.credentials, mode: input.mode, redirect: input.redirect, referrer: input.referrer, referrerPolicy: input.referrerPolicy, integrity: input.integrity });
+      const response = await fetch(input, init);
+      return responseMetadata(new context.Response(response.body, { status: response.status, statusText: response.statusText, headers: responseHeaders(response.headers) }), response);
+    };
+    return context;
+  } });
+}
+
+export async function loadEdgeModule(code, name, reactMode) {
+  if (reactMode !== undefined && reactMode !== 'rsc' && reactMode !== 'ssr') throw new Error('Unknown Edge React mode');
+  let pending;
+  if (reactMode) {
+    pending = reactVMs.get(reactMode);
+    if (!pending) {
+      pending = createEdgeVM(reactMode);
+      reactVMs.set(reactMode, pending);
+      void pending.catch(() => { if (reactVMs.get(reactMode) === pending) reactVMs.delete(reactMode); });
+    }
+  } else pending = createEdgeVM();
+  // This runtime module belongs to one compiled build. Its two React realms
+  // are shared lazily by all pages/boundaries; each bundle has its own factory.
+  const vm = await pending;
+  const module = await runInContext(code, vm.context, { filename: name, timeout: 5000 });
+  if (reactMode) return module;
+  const handlers = new Set(['GET', 'HEAD', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS', 'middleware', 'proxy', 'default']);
+  const result = {};
+  for (const [key, value] of Object.entries(module)) {
+    if (!handlers.has(key) || typeof value !== 'function') { result[key] = value; continue; }
+    result[key] = async (request, ...args) => {
+      const init = { method: request.method, headers: [...request.headers], signal: request.signal, nextConfig: request.nextUrl?._nextConfig };
+      if (!['GET', 'HEAD'].includes(request.method) && request.body) { init.body = request.body; init.duplex = 'half'; }
+      const response = await value(module.__prnext_createRequest(request.url, init), ...args);
+      if (response == null) return response;
+      if (!(response instanceof vm.context.Response)) throw new TypeError('Edge handler must return a Web Response');
+      return new Response(response.body, { status: response.status, statusText: response.statusText, headers: responseHeaders(response.headers) });
+    };
+  }
+  return result;
+}

package/runtime/env.mjs

@@ -0,0 +1,68 @@
+import { readFileSync, statSync } from 'node:fs';
+import path from 'node:path';
+import { parse } from 'dotenv';
+import { expand } from 'dotenv-expand';
+
+// Track only values installed here, preserving shell inputs and runtime changes.
+const loadedValues = new WeakMap();
+
+/** Scope build-time env mutations so later child servers inherit only callers' env. */
+export function snapshotEnvConfig(env = process.env) {
+  const snapshot = { ...env };
+  const provenance = loadedValues.get(env);
+  return () => {
+    for (const key of Object.keys(env)) if (!Object.hasOwn(snapshot, key)) delete env[key];
+    Object.assign(env, snapshot);
+    if (provenance) loadedValues.set(env, provenance);
+    else loadedValues.delete(env);
+  };
+}
+
+export function envFileNames({ dev = false, env = process.env, mode = env.NODE_ENV === 'test' ? 'test' : dev ? 'development' : 'production' } = {}) {
+  if (!['development', 'production', 'test'].includes(mode)) throw new Error('Environment file mode must be development, production or test.');
+  return [`.env.${mode}.local`, ...(mode === 'test' ? [] : ['.env.local']), `.env.${mode}`, '.env'];
+}
+
+/** Load root env files in Next's precedence order, without logging values. */
+export function loadEnvConfig(projectRoot, { dev = false, env = process.env, mode } = {}) {
+  for (const [key, value] of loadedValues.get(env) || []) {
+    if (env[key] === value) delete env[key];
+  }
+  const original = { ...env };
+  const combined = { ...original };
+  const parsedEnv = Object.create(null);
+  const loadedEnvFiles = [];
+  for (const name of envFileNames({ dev, env, mode })) {
+    const filename = path.join(projectRoot, name);
+    let contents;
+    try {
+      if (!statSync(filename).isFile()) continue;
+      contents = readFileSync(filename, 'utf8');
+    } catch (error) {
+      if (error.code === 'ENOENT') continue;
+      throw new Error(`Could not load ${filename}: ${error.code || error.message}`, { cause: error });
+    }
+    let parsed;
+    try { parsed = expand({ parsed: parse(contents), processEnv: combined }).parsed; }
+    catch (error) { throw new Error(`Could not expand variables in ${filename}. Check for circular references.`, { cause: error }); }
+    for (const [key, value] of Object.entries(parsed)) {
+      if (!Object.hasOwn(original, key) && !Object.hasOwn(parsedEnv, key)) parsedEnv[key] = value;
+    }
+    loadedEnvFiles.push(name);
+  }
+  // Expansion uses a scratch object so caller-owned escaped dollars stay intact.
+  for (const [key, value] of Object.entries(parsedEnv)) env[key] = value;
+  loadedValues.set(env, new Map(Object.entries(parsedEnv)));
+  return { combinedEnv: env, parsedEnv, loadedEnvFiles };
+}
+
+export function shouldWatchProjectFile(filename) {
+  if (!filename) return false;
+  const parts = String(filename).split(/[\\/]/);
+  // Contentlayer's generated modules are real application inputs. Its cache
+  // and temporary config bundles stay excluded to avoid generator feedback.
+  if (parts[0] === '.contentlayer' && parts[1] === 'generated') return !parts.slice(2).some(part => part.startsWith('.') || part === 'node_modules');
+  if (parts.length === 1 && /^\.env(?:\.(?:development|production|test))?(?:\.local)?$/.test(parts[0])) return true;
+  if (parts.length === 1 && /^(?:\.postcssrc(?:\.(?:js|mjs|cjs|json))?|\.browserslistrc)$/.test(parts[0])) return true;
+  return !parts.some(part => part === 'node_modules' || part === 'target' || part.startsWith('.'));
+}