@thomas.f/prnext 0.1.0-alpha.1

package/runtime/metadata-route.mjs

@@ -0,0 +1,83 @@
+const list = value => value == null ? [] : Array.isArray(value) ? value : [value];
+const xml = value => String(value).replace(/[&<>"']/g, c => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&apos;' })[c]);
+
+export function serializeMetadataRoute(kind, data) {
+  if (kind === 'manifest') return JSON.stringify(data);
+  if (kind === 'robots') {
+    if (!data || !data.rules) throw new TypeError('robots() must return an object with rules.');
+    let text = '';
+    for (const rule of list(data.rules)) {
+      for (const agent of list(rule.userAgent || '*')) text += `User-Agent: ${agent}\n`;
+      for (const [field, label] of [['allow', 'Allow'], ['disallow', 'Disallow']]) for (const item of list(rule[field])) text += `${label}: ${item}\n`;
+      if (rule.crawlDelay) text += `Crawl-delay: ${rule.crawlDelay}\n`;
+      for (const [key, values] of Object.entries(rule.other || {})) for (const value of list(values)) text += `${key}: ${value}\n`;
+      text += '\n';
+    }
+    if (data.host) text += `Host: ${data.host}\n`;
+    for (const url of list(data.sitemap)) text += `Sitemap: ${url}\n`;
+    return text;
+  }
+  if (kind !== 'sitemap' || !Array.isArray(data)) throw new TypeError('sitemap() must return an array.');
+  const namespaces = { image: 'http://www.google.com/schemas/sitemap-image/1.1', video: 'http://www.google.com/schemas/sitemap-video/1.1', xhtml: 'http://www.w3.org/1999/xhtml' };
+  const used = { image: data.some(item => item.images?.length), video: data.some(item => item.videos?.length), xhtml: data.some(item => Object.keys(item.alternates || {}).length) };
+  let text = '<?xml version="1.0" encoding="UTF-8"?>\n<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"';
+  for (const [key, uri] of Object.entries(namespaces)) if (used[key]) text += ` xmlns:${key}="${uri}"`;
+  text += '>\n';
+  const tag = (name, value, attributes = '') => value == null ? '' : `<${name}${attributes}>${xml(value instanceof Date ? value.toISOString() : value)}</${name}>\n`;
+  for (const item of data) {
+    text += '<url>\n' + tag('loc', item.url);
+    for (const [language, url] of Object.entries(item.alternates?.languages || {})) text += `<xhtml:link rel="alternate" hreflang="${xml(language)}" href="${xml(url)}" />\n`;
+    for (const image of item.images || []) text += '<image:image>\n' + tag('image:loc', image) + '</image:image>\n';
+    for (const video of item.videos || []) {
+      text += '<video:video>\n';
+      for (const field of ['title', 'thumbnail_loc', 'description', 'content_loc', 'player_loc', 'duration', 'view_count', 'tag', 'rating', 'expiration_date', 'publication_date', 'family_friendly', 'requires_subscription', 'live']) text += tag('video:' + field, video[field]);
+      for (const field of ['restriction', 'platform', 'uploader']) if (video[field]) {
+        const attribute = field === 'uploader' ? 'info' : 'relationship';
+        text += tag('video:' + field, video[field].content, video[field][attribute] ? ` ${attribute}="${xml(video[field][attribute])}"` : '');
+      }
+      text += '</video:video>\n';
+    }
+    text += tag('lastmod', item.lastModified) + tag('changefreq', item.changeFrequency) + tag('priority', item.priority) + '</url>\n';
+  }
+  return text + '</urlset>\n';
+}
+export function validateMetadataVariants(rows, name) {
+  if (!Array.isArray(rows) || rows.length > 10000) throw new TypeError(`${name} must return an array with at most 10000 items`);
+  const seen = new Set();
+  for (const item of rows) {
+    if (!item || !['string', 'number'].includes(typeof item.id) || !String(item.id) || /[/\\\x00-\x1f]/.test(String(item.id)) || ['.', '..'].includes(String(item.id))) throw new TypeError(`${name} requires a valid id for every item`);
+    const id = String(item.id);
+    if (seen.has(id)) throw new TypeError(`${name} returned duplicate id ${id}`);
+    seen.add(id);
+  }
+  return rows;
+}
+export function metadataHandler(source, { kind, image, multiple, contentType }) {
+  if (typeof source.default !== 'function') throw new TypeError(`${kind} metadata file must export a default function`);
+  if (['GET', 'HEAD', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS'].some(name => name in source)) throw new Error('Metadata files must export a default metadata function, not HTTP methods');
+  return async (_request, context) => {
+    const { __metadata_id__: rawId, ...params } = await context.params;
+    const id = kind === 'sitemap' ? typeof rawId === 'string' && rawId.endsWith('.xml') ? rawId.slice(0, -4) : undefined : rawId;
+    if (multiple) {
+      const name = image ? 'generateImageMetadata' : 'generateSitemaps';
+      const rows = validateMetadataVariants(await source[name]({ params }), name);
+      if (!rows.some(item => String(item.id) === id)) return new Response('Not Found', { status: 404 });
+    }
+    const result = await source.default({ params: Promise.resolve(params), ...(multiple ? { id: Promise.resolve(id) } : {}) });
+    if (image) {
+      if (!(result instanceof Response)) throw new TypeError(`${kind} must return a Response or ImageResponse`);
+      return result;
+    }
+    return new Response(serializeMetadataRoute(kind, result), { headers: { 'content-type': contentType } });
+  };
+}
+export async function metadataStaticParams(source, { kind, image }, { params = {} } = {}) {
+  const parents = source.generateStaticParams ? await source.generateStaticParams({ params }) : [params];
+  const result = [];
+  const name = image ? 'generateImageMetadata' : 'generateSitemaps';
+  for (const parent of parents) for (const item of validateMetadataVariants(await source[name]({ params: parent }), name)) {
+    result.push({ ...parent, __metadata_id__: String(item.id) + (kind === 'sitemap' ? '.xml' : '') });
+    if (result.length > 10000) throw new Error('Metadata path generation exceeds 10000 paths');
+  }
+  return result;
+}

package/runtime/middleware.mjs

@@ -0,0 +1,186 @@
+import { trackRequestWork } from './request-work.mjs';
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { loadModule } from './module-loader.mjs';
+import { NextRequest, NextResponse } from '../compat/server.cjs';
+import { removeBasePath } from '../compat/paths.cjs';
+import { runRequestContext, currentRequest, runWithoutRequestContext } from '../compat/headers.cjs';
+import { flushCacheWork } from '../compat/data-cache.cjs';
+import { apiTimeoutError, streamingBody, withSignal } from './stream-utils.mjs';
+import { installFetchCache } from './fetch-cache.mjs';
+
+installFetchCache();
+
+const FLIGHT_HEADERS = ['rsc', 'next-router-state-tree', 'x-prnext-router-state', 'next-router-prefetch', 'next-hmr-refresh', 'next-router-segment-prefetch'];
+const HOP_HEADERS = new Set(['connection', 'keep-alive', 'proxy-authenticate', 'proxy-authorization', 'te', 'trailer', 'transfer-encoding', 'upgrade', 'content-length']);
+const MAX_BODY = 8 * 1024 * 1024;
+const MAX_SCOPES = 32;
+const MAX_PROMISES = 128;
+const scopes = new Set();
+let pendingPromises = 0;
+
+function observeBackground(value, entry) {
+  // Keep the reaction detached from the scope closure. A user promise may
+  // remain reachable forever; clearing entry.settle after its deadline must
+  // release the scope and request while still observing late rejections.
+  // Otherwise the child promise itself inherits the request store even after
+  // the detachable callback has been cleared. User work keeps its own context.
+  runWithoutRequestContext(() => {
+    void Promise.resolve(value).then(() => entry.settle?.(), error => entry.settle?.(error));
+  });
+}
+
+function backgroundScope({ timeoutMs, onTimeout, onError }) {
+  const entries = new Set();
+  let active = false, completed = false, closed = false, timer, resolveDone;
+  const scope = { done: new Promise(resolve => { resolveDone = resolve; }) };
+  function close() {
+    if (closed) return;
+    closed = true;
+    clearTimeout(timer);
+    for (const entry of entries) { entry.settle = undefined; pendingPromises--; }
+    entries.clear(); scopes.delete(scope); resolveDone();
+  }
+  function settle(entry, error) {
+    if (!entry.settle) return;
+    entry.settle = undefined; entries.delete(entry); pendingPromises--;
+    if (error) onError(error);
+    if (completed && !entries.size) close();
+  }
+  scope.waitUntil = value => {
+    // Observe even refused registrations: callers often construct a rejected
+    // promise before invoking waitUntil, which must not become unhandled.
+    const entry = { settle: undefined };
+    observeBackground(value, entry);
+    if (closed) throw new Error('waitUntil cannot be called after its middleware invocation has completed');
+    if (pendingPromises >= MAX_PROMISES || (!active && scopes.size >= MAX_SCOPES)) throw new Error('Middleware waitUntil capacity exceeded');
+    if (!active) {
+      active = true; scopes.add(scope);
+      timer = setTimeout(() => {
+        const error = apiTimeoutError('middleware waitUntil', timeoutMs);
+        close(); onTimeout(error); onError(error);
+      }, timeoutMs);
+    }
+    entry.settle = error => settle(entry, error);
+    entries.add(entry); pendingPromises++;
+  };
+  scope.complete = () => { completed = true; if (!entries.size) close(); };
+  return scope;
+}
+
+// Test/shutdown hooks inspect only framework-owned, bounded work. Arbitrary
+// application promises cannot be forcibly canceled after their deadline.
+export function middlewareBackgroundState() { return { scopes: scopes.size, promises: pendingPromises }; }
+export async function drainMiddlewareWork() { await Promise.all([...scopes].map(scope => scope.done)); }
+
+function visibleHeaders(values, normalize) {
+  const headers = new Headers(values);
+  for (const name of [...headers.keys()]) if (name.startsWith('x-middleware-') || name === 'x-prnext-rewrite') headers.delete(name);
+  if (normalize) for (const name of FLIGHT_HEADERS) headers.delete(name);
+  return headers;
+}
+
+export async function runMiddleware(options) {
+  const metadata = options.manifest?.middleware || options.middleware || {};
+  const production = options.production ?? true;
+  const timeoutMs = options.timeoutMs ?? 25_000;
+  const normalize = !(options.manifest?.config?.skipProxyUrlNormalize ?? options.manifest?.config?.skipMiddlewareUrlNormalize);
+  const exposedUrl = new URL(!normalize && options.originalUrl ? options.originalUrl : options.url);
+  if (normalize) exposedUrl.searchParams.delete('_rsc');
+  const headers = visibleHeaders(options.headers || {}, normalize);
+  const controller = new AbortController();
+  const aborted = () => controller.abort(options.signal.reason);
+  if (options.signal?.aborted) aborted();
+  else options.signal?.addEventListener('abort', aborted, { once: true });
+  const headersTimer = setTimeout(() => controller.abort(apiTimeoutError('middleware response headers', timeoutMs)), timeoutMs);
+  let responseComplete = false;
+  let backgroundTimeout;
+  let finalizeInvocation;
+  const report = options.onBackgroundError || (error => console.error('[prnext] Middleware background work failed:', error?.stack || error));
+  const background = backgroundScope({ timeoutMs: options.waitUntilTimeoutMs ?? 25_000,
+    onError: report, onTimeout(error) { backgroundTimeout = error; if (responseComplete) controller.abort(error); } });
+  const finishResponse = () => {
+    responseComplete = true;
+    options.signal?.removeEventListener('abort', aborted);
+    if (backgroundTimeout) controller.abort(backgroundTimeout);
+    finalizeInvocation?.();
+  };
+  let output;
+  try {
+    const basePath = options.manifest?.config?.basePath || '';
+    const internalUrl = new URL(exposedUrl);
+    internalUrl.pathname = removeBasePath(internalUrl.pathname, basePath);
+    return await runRequestContext({ url: internalUrl.href, basePath, method: options.method || 'GET', headers,
+      phase: 'middleware', production, mutableCookies: true, signal: controller.signal }, async () => {
+      const context = currentRequest();
+      let result;
+      let finalized = false;
+      finalizeInvocation = () => {
+        if (finalized) return;
+        finalized = true;
+        context.cookies._mutable = false;
+        context.cacheState.closed = true;
+        if (context.cacheState.pending.size) {
+          try { background.waitUntil(flushCacheWork(context)); }
+          catch (error) { report(error); }
+        }
+        background.complete();
+      };
+      try {
+        controller.signal.throwIfAborted();
+        const module = await withSignal(loadModule(options.modulePath), controller.signal);
+        const exportName = metadata.exportName || metadata.convention || 'middleware';
+        const handler = module[exportName];
+        if (typeof handler !== 'function') throw new TypeError(`Middleware must export a ${exportName} function`);
+        const init = { method: options.method || 'GET', headers, signal: controller.signal };
+        if (!['GET', 'HEAD'].includes(init.method)) {
+          if (typeof options.body === 'string' && options.body.length > Math.ceil(MAX_BODY / 3) * 4) throw Object.assign(new Error('Middleware request exceeds the 8 MiB PRNext limit'), { statusCode: 413 });
+          const body = Buffer.isBuffer(options.body) ? options.body : Buffer.from(options.body || '', 'base64');
+          if (body.byteLength > MAX_BODY) throw Object.assign(new Error('Middleware request exceeds the 8 MiB PRNext limit'), { statusCode: 413 });
+          if (body.byteLength) init.body = body;
+        }
+        const request = new NextRequest(exposedUrl, { ...init, nextConfig: options.manifest?.config });
+        const event = { sourcePage: `/${metadata.convention || 'middleware'}`,
+          waitUntil(value) { trackRequestWork(value, options.signal); background.waitUntil(value); }, passThroughOnException() {},
+          get request() { throw new Error('Read the request from the middleware function first argument'); },
+          respondWith() { throw new Error('Return a Response from the middleware function instead of respondWith()'); } };
+        const pending = trackRequestWork(Promise.resolve().then(() => handler(request, event)), options.signal);
+        void pending.then(value => { if (controller.signal.aborted && value instanceof Response) void value.body?.cancel(controller.signal.reason).catch(() => {}); }, () => {});
+        result = await withSignal(pending, controller.signal);
+        if (result === null || result === undefined) result = NextResponse.next();
+        if (!(result instanceof Response)) throw new TypeError('Middleware must return a Response, null, or undefined');
+        clearTimeout(headersTimer);
+        const responseHeaders = Object.fromEntries(result.headers);
+        const cookies = [...result.headers.getSetCookie(), ...context.outgoingCookies.values()];
+        if (cookies.length) responseHeaders['set-cookie'] = cookies;
+        const nominated = String(responseHeaders.connection || '').split(',').map(name => name.trim().toLowerCase());
+        for (const name of Object.keys(responseHeaders)) if (HOP_HEADERS.has(name) || nominated.includes(name)) delete responseHeaders[name];
+        if (Buffer.byteLength(JSON.stringify(responseHeaders)) > 60 * 1024) throw new Error('Middleware response headers exceed the PRNext metadata limit');
+        // Match native/Next routing precedence: rewrite, then Location, then
+        // continuation. A Location-bearing final response may have a body.
+        const control = responseHeaders['x-middleware-rewrite'] ||
+          (!Object.hasOwn(responseHeaders, 'location') && responseHeaders['x-middleware-next']);
+        const noBody = control || init.method === 'HEAD' || [204, 205, 304].includes(result.status);
+        if (noBody || !result.body) {
+          void result.body?.cancel().catch(() => {});
+          finishResponse();
+          output = { status: result.status, headers: responseHeaders, body: Buffer.alloc(0), cancel() {} };
+        } else {
+          const body = streamingBody(result.body, { signal: controller.signal, timeoutMs,
+            runInContext: AsyncLocalStorage.snapshot(), onCancel: reason => controller.abort(reason), onComplete: finishResponse });
+          output = { status: result.status, headers: responseHeaders, body, cancel: reason => body.cancel(reason) };
+        }
+        context.cookies._mutable = false;
+        context.cacheState.closed = true;
+        return { ...output, finalizeCache: finalizeInvocation };
+      } catch (error) {
+        controller.abort(error);
+        void result?.body?.cancel(error).catch(() => {});
+        finalizeInvocation();
+        throw error;
+      }
+    });
+  } finally {
+    clearTimeout(headersTimer);
+    if (!output) finishResponse();
+  }
+}

package/runtime/module-loader.mjs

@@ -0,0 +1,21 @@
+import { createRequire } from 'node:module';
+import { pathToFileURL } from 'node:url';
+
+const require = createRequire(import.meta.url);
+// Node already retains ESM namespaces. Keep only a bounded index of resolved
+// Pages modules, never import promises (which can retain a request's ALS frame).
+const resolvedPages = new Map();
+export function loadedPagesModule(modulePath) { return resolvedPages.get(modulePath); }
+
+export async function loadModule(modulePath, rememberPage = false) {
+  // CJS must keep honoring application changes to require.cache/exports.
+  if (modulePath.endsWith('.cjs')) return require(modulePath);
+  const imported = import(pathToFileURL(modulePath).href);
+  if (!rememberPage) return imported;
+  const namespace = await imported;
+  if (!resolvedPages.has(modulePath)) {
+    if (resolvedPages.size >= 256) resolvedPages.delete(resolvedPages.keys().next().value);
+    resolvedPages.set(modulePath, namespace);
+  }
+  return namespace;
+}

package/runtime/navigation.mjs

@@ -0,0 +1,16 @@
+/** Decode Next's navigation control signals without treating user errors as 500s. */
+export function navigationResponse(error) {
+  const digest = error?.digest;
+  if (digest === 'NEXT_HTTP_ERROR_FALLBACK;404') return { status: 404, headers: { 'content-type': 'text/plain; charset=utf-8', 'cache-control': 'no-store' }, body: Buffer.from('Not Found') };
+  if (typeof digest !== 'string' || !digest.startsWith('NEXT_REDIRECT;')) return null;
+  const parts = digest.split(';');
+  if (parts.at(-1) === '') parts.pop();
+  const status = Number(parts.pop());
+  const destination = parts.slice(2).join(';');
+  if (![307, 308].includes(status) || !destination || /[\r\n]/.test(destination)) return null;
+  let parsed;
+  try { parsed = new URL(destination, 'http://prnext.invalid'); }
+  catch { return null; }
+  if (!['http:', 'https:'].includes(parsed.protocol)) return null;
+  return { status, headers: { location: destination, 'cache-control': 'no-store' }, body: Buffer.alloc(0) };
+}

package/runtime/og-loader.mjs

@@ -0,0 +1,17 @@
+// Upstream's Node bundle contains HarfBuzz's CommonJS globals and an adjacent
+// hb.wasm reference. Resolve these explicitly for direct prnext/og consumers.
+// Production builds prepare a relocatable module instead and avoid this loader.
+import { createRequire } from 'node:module';
+import { readFile } from 'node:fs/promises';
+import { pathToFileURL } from 'node:url';
+import path from 'node:path';
+export async function loadImageRenderer() {
+  const require = createRequire(import.meta.url);
+  const entry = require.resolve('@vercel/og');
+  const fontDirectory = path.dirname(entry);
+  const satori = createRequire(entry).resolve('satori');
+  const harfbuzzDirectory = path.dirname(createRequire(satori).resolve('harfbuzzjs/hb.wasm'));
+  const source = (await readFile(entry, 'utf8')).replaceAll('import.meta.url', JSON.stringify(pathToFileURL(entry).href));
+  const globals = `import {createRequire as __prnextRequire} from 'node:module';const require=__prnextRequire(${JSON.stringify(pathToFileURL(path.join(fontDirectory, 'index.node.js')).href)}),__filename=${JSON.stringify(entry)},__dirname=${JSON.stringify(harfbuzzDirectory)};\n`;
+  return import('data:text/javascript;base64,' + Buffer.from(globals + source).toString('base64'));
+}

package/runtime/pages-client.mjs

@@ -0,0 +1,197 @@
+import React from 'react';
+import { hydrateRoot } from 'react-dom/client';
+import Router, { RouterProvider, useRouter, installPagesRouter } from '../compat/router.cjs';
+import { createPagesNavigation, pageRouterSnapshot } from './pages-navigation.mjs';
+import { HeadProvider } from '../compat/head.cjs';
+import { preloadReady } from '../compat/dynamic.cjs';
+import { readRewriteMarker, readRewriteHeader } from '../compat/rewrite.cjs';
+import { pageDataRedirectURL } from './client-navigation.mjs';
+import { addBasePath, removeBasePath } from '../compat/paths.cjs';
+import ErrorPage from '../compat/error.cjs';
+import { ScriptContext } from '../compat/script-context.cjs';
+import { initScriptLoader } from '../compat/script-loader.cjs';
+
+const MAX_DATA_BYTES = 16 * 1024 * 1024;
+
+export function pageDataURL(buildId, location, basePath = '') {
+  if (typeof buildId !== 'string' || !buildId) throw new Error('Missing PRNext build ID');
+  const url = new URL(location);
+  const pathname = removeBasePath(url.pathname, basePath).replace(/\/+$/, '') || '/';
+  // /index.json represents the root; literal /index routes need one escape prefix.
+  const firstSegment = decodeURIComponent(pathname.split('/')[1] || '');
+  const asset = pathname === '/' ? '/index' : firstSegment === 'index' ? `/index${pathname}` : pathname;
+  return `${url.origin}${addBasePath(`/_prnext/data/${encodeURIComponent(buildId)}${asset}.json`, basePath)}${url.search}`;
+}
+
+async function readPageData(response, limit = MAX_DATA_BYTES, { discard = false, signal } = {}) {
+  const error = !response.ok && (discard || response.status !== 404)
+    ? new Error(`Page data request failed (${response.status})`)
+    : !discard && !response.headers.get('content-type')?.toLowerCase().includes('application/json')
+      ? new Error('Invalid page data response') : null;
+  if (error) {
+    await response.body?.cancel(error).catch(() => {});
+    throw error;
+  }
+  signal?.throwIfAborted();
+  const reader = response.body?.getReader();
+  if (!reader) {
+    if (discard) return { data: null, bytes: 0 };
+    throw new Error('Empty page data response');
+  }
+  const cancel = () => { void reader.cancel(signal.reason).catch(() => {}); };
+  signal?.addEventListener('abort', cancel, { once: true });
+  const decoder = discard ? null : new TextDecoder();
+  let length = 0;
+  let source = '';
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      signal?.throwIfAborted();
+      if (done) break;
+      length += value.byteLength;
+      if (length > limit) throw new Error('Page data exceeds the response limit');
+      if (decoder) source += decoder.decode(value, { stream: true });
+    }
+    if (discard) return { data: null, bytes: length };
+    source += decoder.decode();
+    return { data: JSON.parse(source), bytes: length };
+  } catch (error) {
+    await reader.cancel(error).catch(() => {});
+    throw error;
+  } finally { signal?.removeEventListener('abort', cancel); reader.releaseLock(); }
+}
+
+export async function readPageDataResponse(response, visibleURL, {
+  maxBytes = MAX_DATA_BYTES, includeBytes = false, fetcher = globalThis.fetch, signal, requestURL = visibleURL,
+} = {}) {
+  try {
+    let legacy = false;
+    for (let redirects = 0; response.headers.get('x-prnext-legacy-navigation') === '1'; redirects++) {
+      legacy = true;
+      const location = response.headers.get('x-prnext-legacy-location');
+      if (location === null) break;
+      if (!response.ok) throw new Error(`Page data request failed (${response.status})`);
+      if (redirects === 20) throw new Error('Too many legacy page redirects');
+      // Location is an HTTP URL relative to the actual data response, not the
+      // browser's visible route. Only the final response may supply a rewrite.
+      const target = new URL(location, response.url || requestURL);
+      if (!['http:', 'https:'].includes(target.protocol)) throw new Error('Unsupported navigation protocol');
+      await response.body?.cancel();
+      signal?.throwIfAborted();
+      response = await fetcher(target.href, { credentials: 'same-origin', redirect: 'follow', signal,
+        headers: { accept: 'application/json', 'x-nextjs-data': '1', 'x-prnext-navigation': '1' } });
+      requestURL = target.href;
+    }
+    if (legacy && !response.ok && (response.status < 300 || response.status >= 400)) throw new Error(`Page data request failed (${response.status})`);
+    const redirect = pageDataRedirectURL(response, visibleURL);
+    if (redirect) {
+      await response.body?.cancel();
+      return { redirect: redirect.href };
+    }
+    // Legacy middleware probes run server hooks for their effects. Their body
+    // does not provide props: the client hook runs after routing is resolved.
+    const result = await readPageData(response, maxBytes, { discard: legacy, signal });
+    const rewrite = readRewriteHeader(response) || result.data?.__PRNEXT_ROUTER__?.rewrite;
+    return { data: result.data, rewrite, ...(legacy ? { legacy: true } : {}), ...(includeBytes ? { bytes: result.bytes,
+      cacheable: !legacy && !rewrite && !/(?:^|[,\s])(?:no-store|private)(?:[,\s=]|$)/i.test(response.headers.get('cache-control') || ''),
+    } : {}) };
+  } catch (error) {
+    await response.body?.cancel(error).catch(() => {});
+    throw error;
+  }
+}
+
+function PageEntry({ Page, App, data }) {
+  const router = useRouter();
+  return App
+    ? React.createElement(App, { ...data.appProps, Component: Page, pageProps: data.props, router })
+    : React.createElement(Page, data.props);
+}
+
+class PagesErrorBoundary extends React.Component {
+  state = { view: this.props.view, error: null };
+  static getDerivedStateFromProps(props, state) {
+    return props.view === state.view ? null : { view: props.view, error: null };
+  }
+  static getDerivedStateFromError(error) { return { error }; }
+  componentDidCatch(error) {
+    if (process.env.NODE_ENV === 'development') globalThis.__PRNEXT_DEV__?.reportError(error);
+    void this.props.reportError(error, this.props.view);
+  }
+  render() {
+    return this.state.error ? React.createElement(ErrorPage, { statusCode: this.state.error.statusCode }) : this.props.children;
+  }
+}
+
+function PagesRoot({ state, committed, reportError, strictMode }) {
+  const [hydrated, setHydrated] = React.useState(false);
+  React.useLayoutEffect(() => { setHydrated(true); committed?.(); }, [state, committed]);
+  // Static HTML needs the visible query once after hydration. Subsequent
+  // navigation snapshots already distinguish href's query from the visible as URL.
+  const router = hydrated && !state.clientSnapshot ? pageRouterSnapshot(state.router, new URL(window.location.href), new URL(window.location.href), state.rewrite || state.router.rewrite) : state.router;
+  return React.createElement(RouterProvider, { router, managed: true },
+    React.createElement(HeadProvider, { restoreDefaults: true },
+      React.createElement(ScriptContext.Provider, { value: { appDir: false, ssr: !hydrated } },
+        React.createElement(PagesErrorBoundary, { view: state, reportError }, React.createElement(PageEntry, { Page: state.Page, App: state.App, data: state })))));
+}
+
+function pagesView(props) {
+  return React.createElement(props.strictMode ? React.StrictMode : React.Fragment, null, React.createElement(PagesRoot, props));
+}
+
+let application;
+async function startPages({ Page, App, pattern, manifestUrl, basePath = '', trailingSlash = false, skipTrailingSlashRedirect = false, assetBase, strictMode = false }) {
+  const data = window.__PRNEXT_DATA__;
+  if (!data?.router || !data.props) throw new Error('Missing PRNext page data');
+  const rewrite = readRewriteMarker(document);
+  const initial = { ...data, router: { ...data.router, basePath, trailingSlash, skipTrailingSlashRedirect }, Page, App, ...(rewrite ? { rewrite } : {}) };
+  let buildId = data.buildId;
+  const container = document.getElementById('__prnext');
+  if (!container) throw new Error('Missing PRNext page root');
+  const scripts = document.getElementById('__PRNEXT_SCRIPT_LOADER__');
+  initScriptLoader(scripts ? JSON.parse(scripts.textContent) : []);
+  scripts?.remove();
+  await preloadReady(data.dynamicIds || []);
+  let root;
+  const controller = createPagesNavigation({ initial, initialRoute: { pattern: pattern || data.router.pathname }, manifestUrl, basePath, trailingSlash, skipTrailingSlashRedirect, assetBase,
+    events: Router.events,
+    commit(state) { return new Promise(resolve => { root.render(pagesView({ state, strictMode, committed: resolve, reportError: controller.reportRenderError })); }); },
+    async readData(url, signal, { speculative, fetcher }) {
+      const abort = new AbortController();
+      const cancel = () => abort.abort(signal.reason);
+      signal.addEventListener('abort', cancel, { once: true });
+      if (signal.aborted) cancel();
+      const timer = setTimeout(() => abort.abort(new Error('Page data request timed out')), 30_000);
+      try {
+        const requestURL = pageDataURL(buildId, url.href, basePath);
+        const response = await fetcher(requestURL, {
+          credentials: 'same-origin', redirect: 'manual', signal: abort.signal,
+          headers: { accept: 'application/json', 'x-nextjs-data': '1', 'x-prnext-navigation': '1', ...(speculative ? { purpose: 'prefetch' } : {}) },
+        });
+        return await readPageDataResponse(response, url.href, { maxBytes: speculative ? 2 * 1024 * 1024 : MAX_DATA_BYTES,
+          includeBytes: speculative, fetcher, signal: abort.signal, requestURL });
+      } finally { clearTimeout(timer); signal.removeEventListener('abort', cancel); }
+    },
+  });
+  installPagesRouter(controller);
+  let resolveHydration;
+  const hydrated = new Promise(resolve => { resolveHydration = resolve; });
+  root = hydrateRoot(container, pagesView({ state: initial, strictMode, committed: resolveHydration, reportError: controller.reportRenderError }));
+  await hydrated;
+  if (data.router.isFallback) void controller.refreshFallback();
+  return { root, router: controller, ...(process.env.NODE_ENV === 'development' ? {
+    async devCommit(options) {
+      buildId = options.dev.buildId;
+      window.__PRNEXT_DATA__.buildId = buildId;
+      await controller.devRefresh({ buildId, manifestUrl: options.manifestUrl });
+    },
+  } : {}) };
+}
+
+export function bootstrapPages(options) {
+  if (process.env.NODE_ENV === 'development' && options.dev && globalThis.__PRNEXT_DEV__) {
+    return globalThis.__PRNEXT_DEV__.bootstrap('pages', options, () => startPages(options));
+  }
+  application ||= startPages(options);
+  return application;
+}

package/runtime/pages-error-props.mjs

@@ -0,0 +1,6 @@
+import { loadPageInitialProps } from './pages-initial-props.mjs';
+
+/** Error hooks use the same App delegation as ordinary legacy Pages. */
+export async function errorInitialProps(Page, context, App, snapshot) {
+  return (await loadPageInitialProps({ Page, App, context, routerSnapshot: snapshot })).props;
+}

package/runtime/pages-errors.mjs

@@ -0,0 +1,85 @@
+import path from 'node:path';
+import {localePath} from '../compat/locale.cjs';
+import {removeBasePath} from '../compat/paths.cjs';
+import { readFile, stat } from 'node:fs/promises';
+import { MAX_RESPONSE_BYTES } from './http.mjs';
+
+function boundedText(value, bytes) {
+  if (typeof value !== 'string') return undefined;
+  const prefix = value.slice(0, bytes);
+  const buffer = Buffer.from(prefix);
+  if (buffer.length <= bytes) return buffer.toString('utf8');
+  let end = bytes;
+  while ((buffer[end] & 0xc0) === 0x80) end--;
+  return buffer.subarray(0, end).toString('utf8');
+}
+
+// Private worker metadata only. Custom prototypes and arbitrary object graphs
+// cannot cross processes; never attach this summary to an HTTP response.
+export function summarizePageFailure(error) {
+  const read = name => { try { return error?.[name]; } catch { return undefined; } };
+  const statusCode = read('statusCode'), code = read('code'), stack = read('stack');
+  return { name: boundedText(read('name'), 128) ?? 'Error',
+    message: boundedText(typeof error === 'string' ? error : read('message'), 2048) ?? 'Page generation failed',
+    ...(typeof stack === 'string' ? { stack: boundedText(stack, 4096) } : {}),
+    ...(Number.isInteger(statusCode) && statusCode >= 100 && statusCode <= 599 ? { statusCode } : {}),
+    ...(typeof code === 'string' ? { code: boundedText(code, 256) }
+      : code === null || typeof code === 'boolean' || typeof code === 'number' && Number.isFinite(code) ? { code } : {}) };
+}
+
+export function restorePageFailure(summary) {
+  if (!summary) return undefined;
+  const value = summarizePageFailure(summary);
+  return Object.assign(new Error(value.message), value);
+}
+
+export function builtinPageError(statusCode = 500, headers = {}) {
+  const title = statusCode === 404 ? 'This page could not be found.' : 'Internal Server Error';
+  return { status: statusCode, headers: { ...headers, 'content-type': 'text/html; charset=utf-8', 'cache-control': 'private, no-cache, no-store, max-age=0, must-revalidate' },
+    body: Buffer.from(`<!DOCTYPE html><html><head><meta charset="utf-8"><title>${statusCode}: ${title}</title></head><body><main><h1>${statusCode}</h1><p>${title}</p></main></body></html>`) };
+}
+
+export function errorRoute(manifest = {}, statusCode, locale) {
+  const id = statusCode === 404 ? manifest.appNotFound || manifest.pagesErrors?.notFound || manifest.pagesErrors?.error
+    : manifest.pagesErrors?.serverError || manifest.pagesErrors?.error;
+  return manifest.routes?.find(route => route.id === (locale && locale !== manifest.config?.i18n?.defaultLocale && id !== manifest.appNotFound ? `${id}-locale-${locale}` : id));
+}
+
+export async function renderPageError(options, { statusCode = 500, error, responseHeaders = {} } = {}) {
+  const i18n = options.manifest?.config?.i18n;
+  const locale = options.route?.locale || (i18n && localePath(removeBasePath(new URL(options.url || 'http://prnext.local').pathname, options.manifest.config.basePath || ''), i18n).locale);
+  const route = errorRoute(options.manifest, statusCode, locale);
+  if (!route) return builtinPageError(statusCode, responseHeaders);
+  const seed = options.manifest?.prerendered?.find(page => page.path === route.pattern);
+  // Native owns the live 404/500 cache, including revalidation after build.
+  if (options.nativeErrors && (seed || route.router === 'app')) {
+    return { status: statusCode, pageError: statusCode, headers: { ...responseHeaders, 'cache-control': 'private, no-cache, no-store, max-age=0, must-revalidate' }, body: Buffer.alloc(0) };
+  }
+  try {
+    const distDir = options.distDir || path.dirname(path.dirname(options.modulePath));
+    if (seed && !options.manifest?.dev) {
+      const file = path.resolve(distDir, seed.file);
+      if (!file.startsWith(path.resolve(distDir) + path.sep) || (await stat(file)).size > MAX_RESPONSE_BYTES) throw new Error('Invalid prerendered error page');
+      return { status: statusCode, headers: { ...seed.headers, ...responseHeaders, 'content-type': 'text/html; charset=utf-8', 'cache-control': 'private, no-cache, no-store, max-age=0, must-revalidate' }, body: await readFile(file) };
+    }
+    const modulePath = path.resolve(distDir, route.module);
+    if (route.router === 'app') {
+      const { renderAppPage } = await import('./app-render.mjs');
+      const result = await renderAppPage({ ...options, modulePath, route, method: 'GET', body: '', stream: false });
+      return { ...result, status: 404 };
+    }
+    const { renderPage } = await import('./render.mjs');
+    responseHeaders = { ...responseHeaders };
+    for (const name of ['content-type', 'content-length', 'content-encoding', 'etag', 'last-modified']) delete responseHeaders[name];
+    const result = await renderPage({ ...options, route, modulePath, params: {}, staticProps: undefined,
+      ...((route.originalPattern || route.pattern) !== '/_error' ? route.appGip && !route.ssg
+        ? { url: `http://prnext.local${route.pattern}${new URL(options.originalUrl || options.url).search}`, originalUrl: options.originalUrl || options.url }
+        : { url: `http://prnext.local${route.pattern}`, originalUrl: undefined } : {}),
+      renderMode: 'error', errorDataRequest: options.renderMode === 'data', errorPage: true,
+      errorStatus: statusCode, error, responseHeaders, method: 'GET', body: '', isFallback: false });
+    return { ...result, headers: { ...result.headers, 'cache-control': 'private, no-cache, no-store, max-age=0, must-revalidate' } };
+  } catch (failure) {
+    console.error('[prnext] Error page failed:', failure?.stack || failure);
+    return builtinPageError(500, responseHeaders);
+  }
+}