@thomas.f/prnext 0.1.0-alpha.1

package/runtime/fetch-cache.mjs

@@ -0,0 +1,379 @@
+import { createHash } from 'node:crypto';
+import cache from '../compat/data-cache.cjs';
+import { dynamicUsage, trackStaticDependency } from '../compat/static-generation.cjs';
+import { recordCacheDependency } from '../compat/use-cache.cjs';
+
+const { cachedValue, deferredValue, optionalRequestContext, cacheState, getCachePaths,
+  inCacheScope, nativeFetch, MAX_CACHE_VALUE_BYTES } = cache;
+const PATCHED = Symbol.for('prnext.fetch-cache');
+const MAX_MEMO_ENTRIES = 128;
+const MAX_MEMO_BYTES = 8 * 1024 * 1024;
+const CAPTURE_IDLE_MS = 1000;
+const CAPTURE_LIFETIME_MS = 20_000;
+let registration;
+
+class UncacheableResponse extends Error {
+  constructor(response) { super('The fetch response is not cacheable'); this.response = response; }
+  async dispose() { await this.response.body?.cancel().catch(() => {}); }
+}
+
+function responseMetadata(response) {
+  return { version: 1, status: response.status, statusText: response.statusText,
+    headers: [...response.headers], url: response.url, redirected: response.redirected,
+    type: response.type, body: response.body !== null };
+}
+
+function decorate(response, metadata) {
+  for (const name of ['url', 'redirected', 'type']) Object.defineProperty(response, name, { value: metadata[name], configurable: true });
+  const clone = response.clone.bind(response);
+  Object.defineProperty(response, 'clone', { value: () => decorate(clone(), metadata), configurable: true });
+  return response;
+}
+
+function encodeResponse(metadata, chunks, length) {
+  const header = Buffer.from(JSON.stringify(metadata));
+  const value = Buffer.allocUnsafe(4 + header.byteLength + length);
+  value.writeUInt32BE(header.byteLength);
+  header.copy(value, 4);
+  let offset = 4 + header.byteLength;
+  for (const chunk of chunks) { value.set(chunk, offset); offset += chunk.byteLength; }
+  return value;
+}
+
+function decodeResponse(value) {
+  if (!Buffer.isBuffer(value) || value.byteLength < 4 || value.byteLength > MAX_CACHE_VALUE_BYTES) throw new Error('Invalid cached fetch response');
+  const offset = 4 + value.readUInt32BE(0);
+  if (offset > value.byteLength) throw new Error('Invalid cached fetch response');
+  const metadata = JSON.parse(value.subarray(4, offset).toString());
+  if (metadata.version !== 1 || !Array.isArray(metadata.headers) || !Number.isInteger(metadata.status) || metadata.status < 200 || metadata.status > 599) throw new Error('Invalid cached fetch response');
+  return decorate(new Response(metadata.body ? value.subarray(offset) : null, metadata), metadata);
+}
+
+function incrementalCodec(url) {
+  return { url,
+    encode(value) {
+      const offset = 4 + value.readUInt32BE(0);
+      const info = JSON.parse(value.subarray(4, offset).toString());
+      return { headers: Object.fromEntries(info.headers), status: info.status, url: info.url,
+        body: value.subarray(offset).toString('base64'), _prnext: { statusText: info.statusText, redirected: info.redirected, type: info.type, body: info.body } };
+    },
+    decode(entry) {
+      const data = entry.data;
+      if (!data || typeof data.body !== 'string' || data.body.length > Math.ceil(MAX_CACHE_VALUE_BYTES / 3) * 4 || data.status !== 200 || !data.headers || typeof data.headers !== 'object') throw new Error('Invalid incremental cached fetch');
+      const bytes = Buffer.from(data.body, 'base64');
+      const headers = new Headers(data.headers);
+      if (headers.has('set-cookie')) throw new Error('Incremental cached fetch contains a session mutation');
+      const info = { version: 1, status: data.status, statusText: data._prnext?.statusText || '', headers: [...headers],
+        url: typeof data.url === 'string' ? data.url : url, redirected: !!data._prnext?.redirected,
+        type: data._prnext?.type || 'basic', body: data._prnext?.body !== false };
+      if (bytes.length + 4 + Buffer.byteLength(JSON.stringify(info)) > MAX_CACHE_VALUE_BYTES) throw new Error('Incremental cached fetch exceeds 2 MiB');
+      return encodeResponse(info, [bytes], bytes.length);
+    },
+  };
+}
+
+// The origin is read once. The caller receives headers immediately; a bounded
+// prefix is pumped ahead so small responses can fill the cache even if ignored.
+// Once capture stops, only demand from that caller pulls further origin bytes.
+function captureResponse(response, { signal, background = false } = {}) {
+  const metadata = responseMetadata(response);
+  const budget = MAX_CACHE_VALUE_BYTES - 4 - Buffer.byteLength(JSON.stringify(metadata));
+  const contentLength = Number(response.headers.get('content-length'));
+  if (budget < 0 || (Number.isFinite(contentLength) && contentLength > budget)) throw new UncacheableResponse(response);
+  if (!response.body) return { response, value: Promise.resolve(encodeResponse(metadata, [], 0)) };
+  const reader = response.body.getReader();
+  let capture = [];
+  let length = 0;
+  let collecting = true;
+  let stopped = false;
+  let ended = false;
+  let failure;
+  let pumping = false;
+  let waiting;
+  const queued = [];
+  let resolveValue;
+  let rejectValue;
+  const value = new Promise((resolve, reject) => { resolveValue = resolve; rejectValue = reject; });
+  // A body can fail after its headers have already been returned to the caller.
+  value.catch(() => {});
+  let idle;
+  const lifetime = setTimeout(() => finish(null), CAPTURE_LIFETIME_MS);
+  lifetime.unref();
+  const onAbort = () => finish(null);
+  function finish(result, error) {
+    if (!collecting) return;
+    collecting = false; capture = [];
+    clearTimeout(idle); clearTimeout(lifetime);
+    signal?.removeEventListener('abort', onAbort);
+    if (error) rejectValue(error); else resolveValue(result);
+    if (background) {
+      stopped = true; queued.length = 0;
+      void reader.cancel(error).catch(() => {});
+    }
+  }
+  function armIdle() {
+    clearTimeout(idle);
+    if (collecting) { idle = setTimeout(() => finish(null), CAPTURE_IDLE_MS); idle.unref(); }
+  }
+  function flushWaiter() {
+    if (!waiting) return;
+    const { controller, resolve } = waiting;
+    if (queued.length) { controller.enqueue(queued.shift()); waiting = undefined; resolve(); }
+    else if (failure) { controller.error(failure); waiting = undefined; resolve(); }
+    else if (ended || stopped) { controller.close(); waiting = undefined; resolve(); }
+  }
+  async function pump() {
+    if (pumping || stopped) return;
+    pumping = true;
+    try {
+      while (!stopped && !ended && (collecting || waiting)) {
+        const next = await reader.read();
+        if (stopped) break;
+        if (next.done) {
+          ended = true;
+          if (collecting) finish(encodeResponse(metadata, capture, length));
+          flushWaiter();
+          break;
+        }
+        if (collecting) {
+          length += next.value.byteLength;
+          if (length > budget) finish(null);
+          else {
+            // The caller may mutate bytes returned by a body reader. Capture
+            // owns a bounded copy, so such mutations cannot poison later hits.
+            capture.push(Uint8Array.from(next.value)); armIdle();
+          }
+        }
+        if (!stopped) queued.push(next.value);
+        flushWaiter();
+      }
+    } catch (error) {
+      failure = error; ended = true;
+      finish(null, error);
+      flushWaiter();
+    } finally { pumping = false; }
+  }
+  const body = new ReadableStream({
+    pull(controller) {
+      return new Promise(resolve => {
+        waiting = { controller, resolve };
+        flushWaiter();
+        if (waiting) void pump();
+      });
+    },
+    async cancel(reason) {
+      stopped = true; queued.length = 0;
+      finish(null);
+      flushWaiter();
+      await reader.cancel(reason);
+    },
+  }, { highWaterMark: 0 });
+  signal?.addEventListener('abort', onAbort, { once: true });
+  if (signal?.aborted) finish(null);
+  armIdle();
+  void pump();
+  return { response: decorate(new Response(body, metadata), metadata), value };
+}
+
+function validateFetchTags(value) {
+  if (value === undefined) return [];
+  if (!Array.isArray(value)) throw new TypeError('fetch next.tags must be an array');
+  const tags = [];
+  let invalid = false;
+  for (const tag of value) {
+    if (typeof tag !== 'string' || tag.length > 256 || tags.length >= 128) { invalid = true; continue; }
+    if (!tags.includes(tag)) tags.push(tag);
+  }
+  if (invalid) console.warn('[prnext] Invalid fetch tags were ignored; use at most 128 strings of at most 256 characters.');
+  return tags;
+}
+
+function fetchPolicy(input, init, context) {
+  const next = { ...input?.next, ...init?.next };
+  const tags = validateFetchTags(next.tags);
+  let revalidate = next.revalidate;
+  let mode = init?.cache ?? (input instanceof Request ? input.cache : undefined);
+  if (revalidate !== undefined && revalidate !== false &&
+      (typeof revalidate !== 'number' || Number.isNaN(revalidate) || revalidate < 0)) throw new TypeError('fetch next.revalidate must be a nonnegative number or false');
+  if ((mode === 'force-cache' && revalidate === 0) || (mode === 'no-store' && (revalidate === false || revalidate > 0))) {
+    if (!context.production) console.warn('[prnext] Conflicting fetch cache and next.revalidate options were ignored.');
+    mode = undefined; revalidate = undefined;
+  }
+  if (mode === 'default') mode = undefined;
+  const configured = context.cacheConfig?.forceNoStore ? 'force-no-store' : context.cacheConfig?.fetchCache || 'auto';
+  if (!['auto', 'default-cache', 'only-cache', 'force-cache', 'default-no-store', 'only-no-store', 'force-no-store'].includes(configured)) throw new TypeError('Invalid route fetchCache setting');
+  const uncached = mode === 'no-store' || mode === 'no-cache' || revalidate === 0;
+  const explicitCache = mode === 'force-cache' || revalidate === false || revalidate > 0;
+  if (configured === 'only-cache' && uncached) throw new Error('fetchCache: only-cache forbids uncached fetches');
+  if (configured === 'only-no-store' && explicitCache) throw new Error('fetchCache: only-no-store forbids cached fetches');
+  if (configured === 'force-no-store') { mode = 'no-store'; revalidate = 0; }
+  else if (configured === 'force-cache') { mode = 'force-cache'; if (revalidate === 0) revalidate = undefined; }
+  else if (!mode && revalidate === undefined) {
+    if (configured === 'default-no-store' || configured === 'only-no-store' || cacheState(context)?.noStore) mode = 'no-store';
+    else if (configured === 'default-cache' || configured === 'only-cache' || context.cacheConfig?.dynamic === 'error') mode = 'force-cache';
+  }
+  if (mode === 'no-store' || mode === 'no-cache' || revalidate === 0) dynamicUsage('an uncached fetch', context);
+  const persist = mode !== 'no-store' && mode !== 'no-cache' && revalidate !== 0 &&
+    (mode === 'force-cache' || revalidate === false || revalidate > 0);
+  if (!persist && context.cacheComponents && !inCacheScope()) dynamicUsage('an uncached fetch', context);
+  return { persist, tags, revalidate: revalidate === false || revalidate === Infinity || revalidate === undefined ? null : revalidate,
+    memoOptions: JSON.stringify([mode, revalidate, tags]) };
+}
+
+async function prepareRequest(input, init) {
+  // Opaque streaming request bodies cannot be hashed before dispatch without
+  // consuming/teeing the upload. They retain native streaming and bypass cache.
+  if (init?.body instanceof ReadableStream || (input instanceof Request && input.body && init?.body === undefined)) return null;
+  const known = init?.body;
+  if ((typeof known === 'string' && Buffer.byteLength(known) > MAX_CACHE_VALUE_BYTES) ||
+      (known instanceof Blob && known.size > MAX_CACHE_VALUE_BYTES) ||
+      (ArrayBuffer.isView(known) && known.byteLength > MAX_CACHE_VALUE_BYTES) ||
+      (known instanceof ArrayBuffer && known.byteLength > MAX_CACHE_VALUE_BYTES)) return null;
+  const form = known instanceof FormData ? [] : null;
+  if (form) {
+    let size = 0;
+    for (const [name, value] of known) {
+      size += Buffer.byteLength(name) + 128 + (typeof value === 'string' ? Buffer.byteLength(value) : value.size + Buffer.byteLength(value.name) + Buffer.byteLength(value.type));
+      if (size > MAX_CACHE_VALUE_BYTES) return null;
+      form.push([name, value]);
+    }
+  }
+  const request = new Request(input, init);
+  const headers = [...request.headers];
+  if (form && !new Headers(init?.headers ?? (input instanceof Request ? input.headers : undefined)).has('content-type')) {
+    // FormData gets a new random wire boundary per Request. Match its ordered
+    // fields and file bytes, while retaining any caller-supplied content type.
+    const contentType = headers.find(header => header[0] === 'content-type');
+    if (contentType) contentType[1] = 'multipart/form-data';
+  }
+  const fields = [request.url, request.method, headers, request.mode, request.credentials,
+    request.redirect, request.referrer, request.referrerPolicy, request.integrity, request.keepalive, request.cache, request.duplex];
+  const metadata = JSON.stringify(fields);
+  if (Buffer.byteLength(metadata) > 64 * 1024) return null;
+  const hash = createHash('sha256').update('prnext-fetch-v1\0').update(metadata).update('\0');
+  if (!request.body) return { request, key: hash.digest('hex') };
+  if (form) {
+    hash.update('form-data\0');
+    for (const [name, value] of form) {
+      if (typeof value === 'string') hash.update(JSON.stringify([name, 'text', value]) + '\0');
+      else {
+        hash.update(JSON.stringify([name, 'file', value.name, value.type, value.size]) + '\0');
+        hash.update(new Uint8Array(await value.arrayBuffer())).update('\0');
+      }
+    }
+    return { request, key: hash.digest('hex') };
+  }
+  const chunks = [];
+  const reader = request.body.getReader();
+  let length = 0;
+  for (;;) {
+    const next = await reader.read();
+    if (next.done) break;
+    chunks.push(next.value); length += next.value.byteLength;
+    if (length > MAX_CACHE_VALUE_BYTES) {
+      // This is a known BodyInit (e.g. FormData), so the untouched caller input
+      // can still be sent normally after cancelling this temporary encoding.
+      await reader.cancel();
+      return null;
+    }
+  }
+  const bytes = Buffer.concat(chunks, length);
+  hash.update(bytes);
+  return { request: new Request(request, { body: bytes, duplex: 'half' }), key: hash.digest('hex') };
+}
+
+function memoState(state) {
+  return state.fetchMemo ||= { entries: new Map(), bytes: 0 };
+}
+
+export function installFetchCache() {
+  let dispatcher = globalThis.fetch[PATCHED];
+  if (!dispatcher) {
+    dispatcher = { handlers: [] };
+    const fetch = function fetch(input, init) {
+      for (let index = dispatcher.handlers.length - 1; index >= 0; index--) {
+        const handler = dispatcher.handlers[index];
+        const context = handler.context();
+        if (context) return handler.fetch(input, init, context);
+      }
+      return nativeFetch(input, init);
+    };
+    Object.defineProperty(fetch, PATCHED, { value: dispatcher });
+    globalThis.fetch = fetch;
+  }
+  if (registration && dispatcher.handlers.includes(registration)) return globalThis.fetch;
+  async function fetch(input, init, context) {
+    if (context.phase === 'pages' || init?.next?.internal) return nativeFetch(input, init);
+    if (inCacheScope()) {
+      const next = init?.next || input?.next || {};
+      if (next.revalidate !== undefined && next.revalidate !== false && (typeof next.revalidate !== 'number' || Number.isNaN(next.revalidate) || next.revalidate < 0)) throw new TypeError('fetch next.revalidate must be a nonnegative number or false');
+      recordCacheDependency(next);
+      return nativeFetch(input, init);
+    }
+    const policy = fetchPolicy(input, init, context);
+    if (context.staticState) trackStaticDependency({ tags: policy.tags, paths: getCachePaths(context),
+      revalidate: context.cacheConfig?.dynamic === 'force-static' && policy.revalidate === 0 ? null : policy.revalidate }, context);
+    if (init?.dispatcher || init?.agent) return nativeFetch(input, init);
+    const state = cacheState(context);
+    const explicitSignal = init?.signal !== undefined || input instanceof Request;
+    const method = String(init?.method ?? (input instanceof Request ? input.method : 'GET')).toUpperCase();
+    const memoize = context.phase === 'render' && method === 'GET' && !explicitSignal;
+    const hardRefresh = !context.production && /(?:^|,)\s*no-cache\s*(?:,|$)/i.test(context.headers?.get?.('cache-control') || '');
+    const persist = policy.persist && !hardRefresh && !context.draftMode && !context.cacheConfig?.forceNoStore;
+    if (!persist && !memoize) return nativeFetch(input, init);
+    const prepared = await prepareRequest(input, init);
+    if (!prepared) return nativeFetch(input, init);
+    const request = prepared.request;
+    request.signal.throwIfAborted();
+    const memo = memoize ? memoState(state) : null;
+    const memoKey = `${prepared.key}:${policy.memoOptions}`;
+    await state.invalidations;
+    if (memo?.entries.has(memoKey)) {
+      const entry = memo.entries.get(memoKey);
+      const value = await entry.promise;
+      if (value) return decodeResponse(value);
+      // A live/noncacheable Response always belongs to one caller. A follower
+      // that cannot reuse completed bytes makes its own native request.
+    }
+    let entry;
+    if (memo && memo.entries.size < MAX_MEMO_ENTRIES && memo.bytes + MAX_CACHE_VALUE_BYTES <= MAX_MEMO_BYTES) {
+      let resolve;
+      entry = { size: MAX_CACHE_VALUE_BYTES, promise: new Promise(done => { resolve = done; }), resolve };
+      memo.entries.set(memoKey, entry); memo.bytes += entry.size;
+    }
+    function settleMemo(value) {
+      if (!entry) return;
+      memo.bytes -= entry.size;
+      if (value) { entry.size = value.byteLength; memo.bytes += entry.size; }
+      else if (memo.entries.get(memoKey) === entry) memo.entries.delete(memoKey);
+      entry.resolve(value);
+      entry = undefined;
+    }
+    const producer = async ({ background = false, signal, cache: canPersist = true } = {}) => {
+      const response = await nativeFetch(request, background && signal ? { signal: AbortSignal.any([request.signal, signal]) } : undefined);
+      // Set-Cookie responses must not replay a session mutation, even when the
+      // request itself explicitly opted into shared caching.
+      if (response.headers.has('set-cookie') || (persist && response.status !== 200) || (!canPersist && !entry)) throw new UncacheableResponse(response);
+      const captured = captureResponse(response, { signal, background });
+      captured.value.then(settleMemo, () => settleMemo(null));
+      return deferredValue(captured.response, captured.value, () => captured.response.body?.cancel());
+    };
+    try {
+      const result = persist ? await cachedValue(prepared.key, producer, {
+        tags: policy.tags, paths: getCachePaths(context), revalidate: policy.revalidate,
+        context, signal: request.signal, incremental: incrementalCodec(request.url),
+      }) : await producer({ cache: false });
+      if (Buffer.isBuffer(result)) { settleMemo(result); return decodeResponse(result); }
+      // Without persistent caching, we unwrap our own deferred value here.
+      if (!persist) return result.value;
+      return result;
+    } catch (error) {
+      settleMemo(null);
+      if (error instanceof UncacheableResponse) return error.response;
+      throw error;
+    }
+  }
+  registration = { context: optionalRequestContext, fetch };
+  dispatcher.handlers.push(registration);
+  return globalThis.fetch;
+}

package/runtime/font-preload.mjs

@@ -0,0 +1,4 @@
+const escape = value => String(value).replace(/[&<>"']/g, character => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' })[character]);
+export function fontPreloads(fonts = [], nonce) {
+  return fonts.map(font => `<link rel="preload" as="font" href="${escape(font.href)}" type="${escape(font.type)}" crossorigin="anonymous"${nonce ? ` nonce="${escape(nonce)}"` : ''}>`).join('');
+}

package/runtime/http.mjs

@@ -0,0 +1,190 @@
+import { IncomingMessage, validateHeaderName, validateHeaderValue } from 'node:http';
+import { Duplex, Writable } from 'node:stream';
+import { revalidatePage } from './pages-revalidate.mjs';
+import { currentRequest } from '../compat/headers.cjs';
+import { draftCookie } from '../compat/draft.cjs';
+import { previewCookies, NAME as PREVIEW_COOKIE } from '../compat/preview.cjs';
+import { serializeCookie } from '../compat/cookies.cjs';
+
+export const MAX_RESPONSE_BYTES = 16 * 1024 * 1024;
+export const forbiddenHeaders = new Set(['connection', 'keep-alive', 'proxy-authenticate', 'proxy-authorization', 'te', 'trailer', 'transfer-encoding', 'upgrade']);
+
+export function escapeHtml(value) {
+  return String(value).replace(/[&<>"']/g, character => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' })[character]);
+}
+
+export function serializeData(value) {
+  return JSON.stringify(value).replace(/[<>&\u2028\u2029]/g, character => ({ '<': '\\u003c', '>': '\\u003e', '&': '\\u0026', '\u2028': '\\u2028', '\u2029': '\\u2029' })[character]);
+}
+
+export function queryFromUrl(url, params = {}) {
+  const query = Object.create(null);
+  for (const [key, value] of url.searchParams) {
+    if (Object.hasOwn(query, key)) query[key] = [...(Array.isArray(query[key]) ? query[key] : [query[key]]), value];
+    else query[key] = value;
+  }
+  return Object.assign(query, params);
+}
+
+function parseCookies(header = '') {
+  const cookies = Object.create(null);
+  for (const part of String(header).split(';')) {
+    const separator = part.indexOf('=');
+    if (separator < 0) continue;
+    const name = part.slice(0, separator).trim();
+    if (!name || Object.hasOwn(cookies, name)) continue;
+    let value = part.slice(separator + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"')) value = value.slice(1, -1);
+    try { cookies[name] = decodeURIComponent(value); } catch { cookies[name] = value; }
+  }
+  return cookies;
+}
+
+export function createRequest({ url, originalUrl, method = 'GET', headers = {}, body = '', params = {} }) {
+  const parsed = new URL(url, 'http://localhost');
+  const visible = originalUrl ? new URL(originalUrl, parsed) : parsed;
+  const socket = new Duplex({ read() {}, write(_chunk, _encoding, callback) { callback(); } });
+  socket.remoteAddress = '127.0.0.1';
+  const request = new IncomingMessage(socket);
+  request.method = method;
+  request.url = `${visible.pathname}${visible.search}`;
+  request.headers = Object.fromEntries(Object.entries(headers).map(([name, value]) => [name.toLowerCase(), value]));
+  request.rawHeaders = Object.entries(request.headers).flatMap(([name, value]) => [name, String(value)]);
+  request.httpVersion = '1.1';
+  request.query = queryFromUrl(parsed, params);
+  request.cookies = parseCookies(request.headers.cookie);
+  request.params = params;
+  request.complete = true;
+  const bytes = Buffer.isBuffer(body) ? body : Buffer.from(body || '', 'base64');
+  if (bytes.length) request.push(bytes);
+  request.push(null);
+  return { request, bytes, url: parsed };
+}
+
+export class CapturedResponse extends Writable {
+  constructor(options, canRevalidate = false) {
+    super(options);
+    this._canRevalidate = canRevalidate;
+    this.statusCode = 200;
+    this.statusMessage = '';
+    this.headersSent = false;
+    this._headers = Object.create(null);
+    this._chunks = [];
+    this._size = 0;
+    // renderPage can consume res.end() synchronously before the stream emits error.
+    // Keep errors observable through .errored/.result() without an unhandled event.
+    this.on('error', () => {});
+  }
+  _write(chunk, _encoding, callback) {
+    this._size += chunk.byteLength;
+    if (this._size > MAX_RESPONSE_BYTES) { callback(new Error('Response exceeds the 16 MiB PRNext limit')); return; }
+    this.headersSent = true;
+    this._chunks.push(Buffer.from(chunk));
+    callback();
+  }
+  get finished() { return this.writableEnded; }
+  setHeader(name, value) {
+    if (this.headersSent) throw new Error('Cannot set headers after they are sent');
+    validateHeaderName(name);
+    const normalized = Array.isArray(value) ? value.map(String) : String(value);
+    for (const item of Array.isArray(normalized) ? normalized : [normalized]) validateHeaderValue(name, item);
+    this._headers[name.toLowerCase()] = normalized;
+    return this;
+  }
+  getHeader(name) { return this._headers[String(name).toLowerCase()]; }
+  getHeaders() { return { ...this._headers }; }
+  getHeaderNames() { return Object.keys(this._headers); }
+  hasHeader(name) { return Object.hasOwn(this._headers, String(name).toLowerCase()); }
+  removeHeader(name) {
+    if (this.headersSent) throw new Error('Cannot remove headers after they are sent');
+    delete this._headers[String(name).toLowerCase()];
+  }
+  appendHeader(name, value) {
+    const existing = this.getHeader(name);
+    return this.setHeader(name, [...(existing === undefined ? [] : Array.isArray(existing) ? existing : [existing]), ...(Array.isArray(value) ? value : [value])]);
+  }
+  writeHead(statusCode, statusMessage, headers) {
+    this.status(statusCode);
+    if (typeof statusMessage === 'string') this.statusMessage = statusMessage;
+    else headers = statusMessage;
+    if (Array.isArray(headers)) {
+      for (let i = 0; i < headers.length; i += 2) this.appendHeader(headers[i], headers[i + 1]);
+    } else {
+      for (const [name, value] of Object.entries(headers || {})) this.setHeader(name, value);
+    }
+    this.headersSent = true;
+    return this;
+  }
+  flushHeaders() { this.headersSent = true; }
+  status(code) {
+    if (!Number.isInteger(code) || code < 100 || code > 599) throw new TypeError('Invalid HTTP status code');
+    this.statusCode = code;
+    return this;
+  }
+  setDraftMode({ enable = true } = {}) {
+    if (typeof enable !== 'boolean') throw new TypeError('setDraftMode enable must be a boolean');
+    const context = currentRequest();
+    this.appendHeader('set-cookie', serializeCookie(draftCookie(context, enable, { keepValue: true })));
+    this.setHeader('cache-control', 'private, no-cache, no-store, max-age=0');
+    context.draftChanged = true;
+    return this;
+  }
+  clearPreviewData({ path = '/' } = {}) {
+    const context = currentRequest();
+    this.appendHeader('set-cookie', serializeCookie(draftCookie(context, false, { path })));
+    this.appendHeader('set-cookie', serializeCookie({ ...draftCookie(context, false, { path }), name: PREVIEW_COOKIE }));
+    this.setHeader('cache-control', 'private, no-cache, no-store, max-age=0');
+    context.draftChanged = true;
+    return this;
+  }
+  setPreviewData(data, options) {
+    const context = currentRequest();
+    const cookies = previewCookies(context, data, options);
+    for (const cookie of cookies) this.appendHeader('set-cookie', serializeCookie(cookie));
+    this.setHeader('cache-control', 'private, no-cache, no-store, max-age=0');
+    context.draftChanged = true;
+    return this;
+  }
+  json(value) {
+    this.setHeader('content-type', 'application/json; charset=utf-8');
+    return this.end(JSON.stringify(value));
+  }
+  send(value) {
+    if (value === null || value === undefined) return this.end();
+    if (Buffer.isBuffer(value) || value instanceof Uint8Array) {
+      if (!this.hasHeader('content-type')) this.setHeader('content-type', 'application/octet-stream');
+      return this.end(value);
+    }
+    if (typeof value === 'object' || typeof value === 'boolean' || typeof value === 'number') return this.json(value);
+    if (!this.hasHeader('content-type')) this.setHeader('content-type', 'text/html; charset=utf-8');
+    return this.end(String(value));
+  }
+  redirect(code, destination) {
+    if (typeof code === 'string') { destination = code; code = 307; }
+    this.status(code);
+    this.setHeader('location', destination);
+    return this.end(destination);
+  }
+  revalidate(path, options) { return revalidatePage(this, path, options); }
+  end(chunk, encoding, callback) {
+    this.headersSent = true;
+    return super.end(chunk, encoding, callback);
+  }
+  result() {
+    if (this.errored) throw this.errored;
+    if (!Number.isInteger(this.statusCode) || this.statusCode < 100 || this.statusCode > 599) throw new Error('Invalid response status');
+    const headers = Object.fromEntries(Object.entries(this._headers).filter(([name]) => !forbiddenHeaders.has(name) && name !== 'content-length').map(([name, value]) => [name, Array.isArray(value) ? [...value] : value]));
+    return { status: this.statusCode, headers, body: [204, 205, 304].includes(this.statusCode) ? Buffer.alloc(0) : Buffer.concat(this._chunks) };
+  }
+}
+
+export function plainResponse(status, message) {
+  return { status, headers: { 'content-type': 'text/plain; charset=utf-8' }, body: Buffer.from(message) };
+}
+
+export function errorResponse(error, production = process.env.NODE_ENV === 'production') {
+  console.error('[prnext]', error?.stack || error);
+  const status = [400, 504].includes(error?.statusCode) ? error.statusCode : 500;
+  const message = status === 400 ? 'Bad Request' : status === 504 ? 'Gateway Timeout' : 'Internal Server Error';
+  return plainResponse(status, production || status === 400 ? message : String(error?.stack || error));
+}

package/runtime/incremental-cache.mjs

@@ -0,0 +1,83 @@
+import { createHash } from 'node:crypto';
+import { readFile, stat } from 'node:fs/promises';
+import legacy from '../compat/incremental-cache.cjs';
+
+const MAX_BYTES = 16 * 1024 * 1024;
+const kinds = new Set(['PAGES', 'APP_PAGE', 'APP_ROUTE']);
+const empty = status => ({ status, headers: {}, body: Buffer.alloc(0) });
+function bytes(value) {
+  if (!(value instanceof Uint8Array) || value.byteLength > MAX_BYTES) throw new Error('Invalid incremental cache bytes');
+  return Buffer.from(value.buffer, value.byteOffset, value.byteLength);
+}
+async function file(filename) {
+  if (typeof filename !== 'string') throw new Error('Missing incremental cache file');
+  if ((await stat(filename)).size > MAX_BYTES) throw new Error('Incremental cache file exceeds 16 MiB');
+  const value = await readFile(filename);
+  if (value.length > MAX_BYTES) throw new Error('Incremental cache file exceeds 16 MiB');
+  return value;
+}
+function metadata(value) {
+  const info = value?._prnext;
+  if (!info || info.version !== 1 || !Array.isArray(info.tags) || !Array.isArray(info.paths) ||
+      (info.revalidate !== false && (!Number.isInteger(info.revalidate) || info.revalidate < 0))) throw new Error('Invalid incremental cache metadata');
+  if (info.tags.length > 128 || info.paths.length > 128 || [...info.tags, ...info.paths].some(tag => typeof tag !== 'string' || tag.length > 8192)) throw new Error('Invalid incremental cache associations');
+  if (Buffer.byteLength(JSON.stringify(info)) > 48 * 1024) throw new Error('Incremental cache metadata exceeds its budget');
+  return info;
+}
+function implicit(paths = []) {
+  return paths.map(value => { const separator = value.indexOf(':'); return '_N_T_' + value.slice(separator + 1).replace(/\/$/, '') + '/' + value.slice(0, separator); });
+}
+
+/** Private worker operation. Rust still owns admission, routing, file pairs and transport. */
+export async function runIncrementalCache(options) {
+  if (!options.manifest?.config?.cacheHandler) throw new Error('No incremental cache handler configured');
+  if (typeof options.body !== 'string' || options.body.length > 256 * 1024) throw new Error('Invalid incremental cache operation');
+  const input = JSON.parse(Buffer.from(options.body, 'base64').toString());
+  if (!input || typeof input.key !== 'string' || input.key.length > 8192 || !kinds.has(input.kind)) throw new Error('Invalid incremental cache key or kind');
+  const context = { ...options, cacheHandler: options.manifest.config.cacheHandler, cacheMaxMemorySize: options.manifest.config.cacheMaxMemorySize };
+  if (input.op === 'invalidate') {
+    await legacy.invalidate(context, { tags: input.tags, mode: 'expire' });
+    return empty(204);
+  }
+  if (input.op === 'set') {
+    const html = await file(input.htmlFile);
+    const data = input.kind === 'APP_ROUTE' ? Buffer.alloc(0) : await file(input.dataFile);
+    if (html.length + data.length > MAX_BYTES) return empty(413);
+    const info = { version: 1, revalidate: input.revalidate, tags: input.tags || [], paths: input.paths || [] };
+    const value = { kind: input.kind, headers: input.headers || {}, status: input.status, _prnext: info };
+    metadata(value);
+    if (input.kind === 'APP_ROUTE') value.body = html;
+    else {
+      value.html = html.toString();
+      if (input.kind === 'APP_PAGE') value.rscData = data;
+      else value.pageData = JSON.parse(data.toString());
+    }
+    const tags = [...new Set([...info.tags, ...implicit(info.paths)])];
+    if (tags.length) value.headers = { ...value.headers, 'x-next-cache-tags': tags.join(',') };
+    await legacy.setEntry(input.key, value, context, { tags, cacheControl: { revalidate: info.revalidate }, isRoutePPREnabled: false });
+    return empty(204);
+  }
+  if (input.op !== 'get') throw new Error('Unknown incremental cache operation');
+  const entry = await legacy.getEntry(input.key, input.kind, context, { tags: input.tags || [], softTags: implicit(input.paths) });
+  if (!entry?.value) return empty(204);
+  const value = entry.value;
+  if (value.kind !== input.kind || typeof entry.lastModified !== 'number' || !Number.isFinite(entry.lastModified) || entry.lastModified < -1 || entry.lastModified > Date.now() + 60_000) throw new Error('Invalid incremental cache entry');
+  const info = metadata(value);
+  if (!Number.isInteger(value.status) || value.status < 200 || value.status > 599) throw new Error('Invalid incremental cached status');
+  if (!value.headers || typeof value.headers !== 'object' || Array.isArray(value.headers) || Buffer.byteLength(JSON.stringify(value.headers)) > 48 * 1024) throw new Error('Invalid incremental cached headers');
+  let html, data = Buffer.alloc(0);
+  if (input.kind === 'APP_ROUTE') html = bytes(value.body);
+  else {
+    if (typeof value.html !== 'string' || Buffer.byteLength(value.html) > MAX_BYTES) throw new Error('Invalid incremental cached HTML');
+    html = Buffer.from(value.html);
+    data = input.kind === 'APP_PAGE' ? bytes(value.rscData) : Buffer.from(JSON.stringify(value.pageData));
+  }
+  if (html.length + data.length > MAX_BYTES) throw new Error('Incremental cache entry exceeds 16 MiB');
+  const cacheVersion = createHash('sha256').update(JSON.stringify([entry.lastModified, value.status, value.headers, info])).update(html).update(data).digest('hex');
+  if (input.knownVersion === cacheVersion) return { ...empty(304), headers: { 'x-prnext-cache-version': cacheVersion } };
+  const headers = { ...value.headers }; delete headers['x-next-cache-tags'];
+  return { status: value.status, headers, body: [html, data],
+    isr: { ...(input.kind === 'APP_ROUTE' ? { kind: 'route' } : {}), revalidate: entry.lastModified < 0 ? 0 : info.revalidate,
+      htmlLength: html.length, dataLength: data.length, tags: info.tags, paths: info.paths,
+      lastModified: entry.lastModified, cacheVersion } };
+}