@thomas.f/prnext 0.1.0-alpha.1

package/compat/cookies.cjs

@@ -0,0 +1,129 @@
+'use strict';
+
+function parseCookieHeader(value = '') {
+  const values = new Map();
+  for (const part of String(value).split(';')) {
+    const separator = part.indexOf('=');
+    if (separator < 1) continue;
+    const name = part.slice(0, separator).trim();
+    let value = part.slice(separator + 1).trim();
+    try { value = decodeURIComponent(value); } catch { /* Preserve malformed user input. */ }
+    values.set(name, { name, value });
+  }
+  return values;
+}
+
+function serializeCookie(cookie) {
+  const { name, value = '', path = '/', domain, expires, maxAge, httpOnly, secure, sameSite, priority, partitioned } = cookie;
+  if (!/^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/.test(name)) throw new TypeError('Invalid cookie name');
+  const result = [`${name}=${encodeURIComponent(String(value))}`];
+  for (const [key, attribute] of [['Path', path], ['Domain', domain]]) {
+    if (attribute !== undefined && attribute !== false) {
+      if (/[;\r\n\u0000]/.test(String(attribute))) throw new TypeError(`Invalid cookie ${key}`);
+      result.push(`${key}=${attribute}`);
+    }
+  }
+  if (expires !== undefined) {
+    const date = expires instanceof Date ? expires : new Date(expires);
+    if (!Number.isFinite(date.getTime())) throw new TypeError('Invalid cookie expiry');
+    result.push(`Expires=${date.toUTCString()}`);
+  }
+  if (maxAge !== undefined) {
+    if (!Number.isFinite(maxAge)) throw new TypeError('Invalid cookie maxAge');
+    result.push(`Max-Age=${Math.floor(maxAge)}`);
+  }
+  if (httpOnly) result.push('HttpOnly');
+  if (secure) result.push('Secure');
+  if (sameSite) {
+    const normalized = sameSite === true ? 'strict' : String(sameSite).toLowerCase();
+    if (!['lax', 'strict', 'none'].includes(normalized)) throw new TypeError('Invalid cookie sameSite');
+    result.push(`SameSite=${normalized[0].toUpperCase()}${normalized.slice(1)}`);
+  }
+  if (priority) {
+    const normalized = String(priority).toLowerCase();
+    if (!['low', 'medium', 'high'].includes(normalized)) throw new TypeError('Invalid cookie priority');
+    result.push(`Priority=${normalized[0].toUpperCase()}${normalized.slice(1)}`);
+  }
+  if (partitioned) result.push('Partitioned');
+  return result.join('; ');
+}
+
+function parseResponseCookie(header) {
+  const [pair, ...attributes] = header.split(';');
+  const cookie = parseCookieHeader(pair).values().next().value;
+  if (!cookie) return;
+  for (const attribute of attributes) {
+    const separator = attribute.indexOf('=');
+    const key = (separator < 0 ? attribute : attribute.slice(0, separator)).trim().toLowerCase();
+    const value = separator < 0 ? '' : attribute.slice(separator + 1).trim();
+    if (['path', 'domain'].includes(key)) cookie[key] = value;
+    else if (key === 'expires') {
+      const date = new Date(value);
+      if (Number.isFinite(date.getTime())) cookie.expires = date;
+    } else if (key === 'max-age' && /^-?\d+$/.test(value)) cookie.maxAge = Number(value);
+    else if (key === 'httponly') cookie.httpOnly = true;
+    else if (key === 'secure' || key === 'partitioned') cookie[key] = true;
+    else if (key === 'samesite' && ['strict', 'lax', 'none'].includes(value.toLowerCase())) cookie.sameSite = value.toLowerCase();
+    else if (key === 'priority' && ['low', 'medium', 'high'].includes(value.toLowerCase())) cookie.priority = value.toLowerCase();
+  }
+  return cookie;
+}
+
+class CookieStore {
+  constructor(header, { mutable = false, onChange } = {}) {
+    this._cookies = parseCookieHeader(header);
+    this._mutable = mutable;
+    this._onChange = onChange;
+  }
+  get size() { return this._cookies.size; }
+  get(name) { const value = this._cookies.get(typeof name === 'object' ? name.name : name); return value && { ...value }; }
+  getAll(name) { return [...this._cookies.values()].filter(cookie => !name || cookie.name === (typeof name === 'object' ? name.name : name)).map(cookie => ({ ...cookie })); }
+  has(name) { return this._cookies.has(name); }
+  set(name, value, options = {}) {
+    if (!this._mutable) throw new Error('Cookies can only be modified in a Route Handler or Server Action');
+    const cookie = typeof name === 'object' ? { ...name } : { ...options, name, value };
+    serializeCookie(cookie);
+    this._cookies.set(cookie.name, cookie);
+    this._onChange?.(cookie, false);
+    return this;
+  }
+  delete(name) {
+    if (!this._mutable) throw new Error('Cookies can only be modified in a Route Handler or Server Action');
+    const cookie = typeof name === 'object' ? name : { name };
+    this._cookies.delete(cookie.name);
+    this._onChange?.({ ...cookie, value: '', expires: new Date(0), maxAge: 0 }, true);
+    return this;
+  }
+  clear() { for (const name of this._cookies.keys()) this.delete(name); return this; }
+  toString() { return [...this._cookies.values()].map(({ name, value }) => `${name}=${encodeURIComponent(value)}`).join('; '); }
+  *[Symbol.iterator]() { for (const [name, cookie] of this._cookies) yield [name, { ...cookie }]; }
+}
+
+class ResponseCookieStore extends CookieStore {
+  constructor(headers) {
+    super('', { mutable: true });
+    this._headers = headers;
+    for (const header of headers.getSetCookie()) {
+      const cookie = parseResponseCookie(header);
+      if (cookie) this._cookies.set(cookie.name, cookie);
+    }
+    this._onChange = () => {
+      headers.delete('set-cookie');
+      for (const cookie of this._cookies.values()) headers.append('set-cookie', serializeCookie(cookie));
+    };
+  }
+  set(name, value, options = {}) {
+    const cookie = typeof name === 'object' ? { ...name } : { ...options, name, value };
+    cookie.path ??= '/';
+    if (typeof cookie.expires === 'number') cookie.expires = new Date(cookie.expires);
+    if (cookie.maxAge) cookie.expires = new Date(Date.now() + cookie.maxAge * 1000);
+    return super.set(cookie);
+  }
+  delete(name) {
+    const cookie = typeof name === 'object' ? name : { name };
+    return this.set({ ...cookie, value: '', expires: new Date(0) });
+  }
+  toString() { return [...this._cookies.values()].map(serializeCookie).join('; '); }
+}
+
+module.exports = { CookieStore, ResponseCookieStore, parseCookieHeader, serializeCookie };

package/compat/data-cache.cjs

@@ -0,0 +1,389 @@
+'use strict';
+const { AsyncLocalStorage, AsyncResource } = require('node:async_hooks');
+const http = require('node:http');
+const { setTimeout: delay } = require('node:timers/promises');
+const { trackStaticDependency } = require('./static-generation.cjs');
+
+// Capture before the runtime installs its application-facing fetch wrapper.
+const nativeFetchSymbol = Symbol.for('prnext.nativeFetch');
+const nativeFetch = globalThis[nativeFetchSymbol] ||= globalThis.fetch.bind(globalThis);
+const cacheStorage = new AsyncLocalStorage();
+const owners = new Map();
+const MAX_CACHE_VALUE_BYTES = 2 * 1024 * 1024;
+const MAX_PENDING_OWNERS = 1024;
+const WAIT_TIMEOUT_MS = 25_000;
+const DEFERRED_VALUE = Symbol('PRNext deferred cache value');
+// Cache RPC is a local JSON protocol, not an application fetch. Keep its socket
+// pool small and outside request AsyncLocalStorage stores.
+const rpcScope = new AsyncResource('prnext-cache-transport');
+// Keep the bounded active pool reusable across bursts: trimming it to four
+// idle sockets churns ephemeral ports under concurrent PPR traffic. Idle
+// connections expire after 30 seconds and retain no request context.
+const rpcAgent = new http.Agent({ keepAlive: true, maxSockets: 32, maxTotalSockets: 32, maxFreeSockets: 32, timeout: 30_000 });
+function localRpc(target, body, signal) {
+  return rpcScope.runInAsyncScope(() => new Promise((resolve, reject) => {
+    let settled = false;
+    const finish = (error, value) => {
+      if (settled) return;
+      settled = true;
+      signal?.removeEventListener('abort', abort);
+      if (error) reject(error); else resolve(value);
+    };
+    const request = http.request(target.url, { method: 'POST', agent: rpcAgent,
+      headers: { 'content-type': 'application/json', authorization: `Bearer ${target.token}`, 'content-length': Buffer.byteLength(body) },
+    }, response => {
+      let size = 0;
+      const chunks = [];
+      response.on('error', error => finish(error));
+      response.on('data', chunk => {
+        size += chunk.length;
+        if (size > 4 * 1024 * 1024) request.destroy(new Error('Cache RPC response exceeds 4 MiB'));
+        else if (response.statusCode >= 200 && response.statusCode < 300) chunks.push(chunk);
+      });
+      response.on('end', () => {
+        const ok = response.statusCode >= 200 && response.statusCode < 300;
+        try { finish(null, { ok, status: response.statusCode, value: ok ? JSON.parse(Buffer.concat(chunks, size).toString()) : undefined }); }
+        catch (error) { finish(error); }
+      });
+    });
+    const abort = () => request.destroy(signal.reason instanceof Error ? signal.reason : new Error('Cache RPC aborted'));
+    request.on('error', error => finish(error));
+    signal?.addEventListener('abort', abort, { once: true });
+    if (signal?.aborted) abort(); else request.end(body);
+  }));
+}
+
+function createCacheState() {
+  return { pending: new Set(), invalidations: Promise.resolve(), noStore: false, refresh: false };
+}
+let requestReader;
+function optionalRequestContext() {
+  // Lazy access avoids a cycle when headers.cjs imports the scope guard.
+  try { requestReader ||= require('./headers.cjs').currentRequest; return requestReader?.(); } catch { return undefined; }
+}
+function cacheState(context = optionalRequestContext()) {
+  if (!context) return undefined;
+  return context.cacheState ||= createCacheState();
+}
+function inCacheScope() { return Boolean(cacheStorage.getStore()); }
+function currentCacheScope() { return cacheStorage.getStore(); }
+function runCacheScope(callback, scope = true) { return cacheStorage.run(scope, callback); }
+
+function validateTags(tags = []) {
+  if (!Array.isArray(tags) || tags.length > 128) throw new TypeError('Cache tags must be an array with at most 128 entries');
+  for (const tag of tags) {
+    if (typeof tag !== 'string' || tag.length > 256) throw new TypeError('Cache tags must be strings of at most 256 characters');
+  }
+  return [...new Set(tags)];
+}
+function validateRevalidate(value, { allowZero = false } = {}) {
+  if (value === undefined || value === false || value === null) return null;
+  if (typeof value !== 'number' || !Number.isFinite(value) || (allowZero ? value < 0 : value <= 0)) {
+    throw new TypeError(`Cache revalidate must be ${allowZero ? 'a nonnegative' : 'a positive'} number of seconds or false`);
+  }
+  return value;
+}
+
+function normalizeCachePath(value, { groups = false } = {}) {
+  if (typeof value !== 'string' || !value.startsWith('/') || value.startsWith('//') || value.includes('\\')) {
+    throw new TypeError('Cache paths must be absolute application paths');
+  }
+  if (value.length > 1024) throw new TypeError('Cache paths must not exceed 1024 characters');
+  if (groups) value = value.split('/').filter(segment => !/^\([^/]+\)$/.test(segment)).join('/') || '/';
+  const pathname = new URL(value, 'http://prnext.local').pathname
+    .replace(/%[0-9a-f]{2}/gi, escape => {
+      const character = String.fromCharCode(parseInt(escape.slice(1), 16));
+      return /[a-z\d_.~-]/i.test(character) ? character : escape.toUpperCase();
+    });
+  return pathname.replace(/\/+$/, '') || '/';
+}
+function getCachePaths(context = optionalRequestContext()) {
+  if (!context) return [];
+  const paths = new Set();
+  const add = pathname => {
+    paths.add(`page:${pathname}`);
+    paths.add('layout:/');
+    const segments = pathname.split('/').filter(Boolean);
+    for (let index = 1; index <= segments.length; index++) paths.add(`layout:/${segments.slice(0, index).join('/')}`);
+  };
+  if (context.url) add(normalizeCachePath(new URL(context.url, 'http://prnext.local').pathname));
+  else if (context.pathname) add(normalizeCachePath(context.pathname));
+  const pattern = context.route?.pattern || context.routePattern;
+  if (pattern) add(normalizeCachePath(pattern, { groups: true }));
+  return [...paths];
+}
+
+function endpoint() {
+  const url = process.env.PRNEXT_CACHE_URL;
+  const token = process.env.PRNEXT_CACHE_TOKEN;
+  return url && token ? { url, token } : undefined;
+}
+async function cacheGeneration(signal) {
+  const target = endpoint();
+  if (!target) return null;
+  const result = await rpc(target, { op: 'generation' }, signal);
+  if (!Number.isSafeInteger(result.generation) || result.generation < 0) throw new Error('Invalid PRNext cache generation');
+  return result.generation;
+}
+
+/** Coordinate external backend fills across local Node workers without storing a second value. */
+async function acquireExternalCacheLease(key, signal) {
+  const target = endpoint();
+  if (!target) return undefined;
+  const digest = require('node:crypto').createHash('sha256').update('prnext-external-lease\0').update(key).digest('hex');
+  const deadline = Date.now() + WAIT_TIMEOUT_MS;
+  let waited = false;
+  while (Date.now() < deadline) {
+    throwIfAborted(signal);
+    let entry;
+    try { entry = await rpc(target, { op: 'read', key: digest, tags: [], paths: [], revalidate: null, forceFresh: true }, signal); }
+    catch { throwIfAborted(signal); return undefined; }
+    if (entry.state === 'miss' && entry.lease) return { waited, release: () => release(target, digest, entry.lease),
+      valid: async () => { try { return (await rpc(target, { op: 'leaseStatus', key: digest, lease: entry.lease }, signal)).valid === true; } catch { return false; } },
+    };
+    if (entry.state !== 'pending') return undefined;
+    waited = true;
+    await delay(Math.min(Math.max(Number(entry.retryAfterMs) || 20, 5), 100), undefined, { signal });
+  }
+  throw new Error('Timed out waiting for a native incremental cache lease');
+}
+async function rpc(target, operation, signal) {
+  const body = JSON.stringify(operation);
+  const url = new URL(target.url);
+  const local = url.protocol === 'http:' && ['127.0.0.1', '[::1]', 'localhost'].includes(url.hostname);
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(new DOMException('The operation was aborted due to timeout', 'TimeoutError')), 5000);
+  timer.unref();
+  try {
+    const operationSignal = signal ? AbortSignal.any([signal, controller.signal]) : controller.signal;
+    let retryMs = 10;
+    while (true) {
+      const response = local ? await localRpc(target, body, operationSignal) : await nativeFetch(target.url, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json', authorization: `Bearer ${target.token}` },
+        body,
+        signal: operationSignal,
+      });
+      // The deadline covers the JSON body as well as response headers. A
+      // completed RPC must release its timer and inherited request context.
+      if (response.ok) return local ? response.value : await response.json();
+      await response.body?.cancel();
+      // The native service bounds admission before doing any operation. Retry
+      // temporary saturation instead of turning a burst of misses into origin work.
+      if (response.status !== 503) throw new Error(`PRNext data cache ${operation.op} failed (${response.status})`);
+      await delay(retryMs + Math.floor(Math.random() * 10), undefined, { signal: operationSignal });
+      retryMs = Math.min(retryMs * 2, 200);
+    }
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function throwIfAborted(signal) { signal?.throwIfAborted(); }
+function deferredValue(value, cacheValue, dispose) {
+  return { [DEFERRED_VALUE]: true, value, cacheValue: Promise.resolve(cacheValue), dispose };
+}
+function untilAborted(promise, signal) {
+  if (!signal) return Promise.resolve(promise);
+  return new Promise((resolve, reject) => {
+    const abort = () => { cleanup(); reject(signal.reason); };
+    const cleanup = () => signal.removeEventListener('abort', abort);
+    signal.addEventListener('abort', abort, { once: true });
+    if (signal.aborted) abort();
+    Promise.resolve(promise).then(value => { cleanup(); resolve(value); }, error => { cleanup(); reject(error); });
+  });
+}
+function bufferValue(value) {
+  if (!Buffer.isBuffer(value) && !(value instanceof Uint8Array)) throw new TypeError('Cache producers must return bytes');
+  return Buffer.isBuffer(value) ? value : Buffer.from(value.buffer, value.byteOffset, value.byteLength);
+}
+function decodeValue(value) {
+  if (typeof value !== 'string' || value.length > Math.ceil(MAX_CACHE_VALUE_BYTES / 3) * 4) throw new Error('Invalid PRNext data cache value');
+  const bytes = Buffer.from(value, 'base64');
+  if (bytes.length > MAX_CACHE_VALUE_BYTES) throw new Error('Invalid PRNext data cache value');
+  return bytes;
+}
+
+async function release(target, key, lease) {
+  try { await rpc(target, { op: 'release', key, lease }, AbortSignal.timeout(1000)); } catch { /* A native lease expires even if its owner disappears. */ }
+}
+function trackBackground(state, work) {
+  const pending = work.catch(async error => {
+    // Fetch may use a thrown sentinel to return an uncacheable live Response.
+    // Background refresh has no consumer, so release that response body too.
+    try { await untilAborted(error?.dispose?.(), AbortSignal.timeout(1000)); } catch { /* Preserve the previous cached value. */ }
+  });
+  if (state) {
+    state.pending.add(pending);
+    void pending.finally(() => state.pending.delete(pending));
+  }
+}
+
+async function compute(target, key, lease, producer, options) {
+  const identity = `${target.url}\n${key}`;
+  const controller = new AbortController();
+  const signal = options.signal ? AbortSignal.any([controller.signal, options.signal]) : controller.signal;
+  const timer = setTimeout(() => controller.abort(new Error('PRNext data cache producer timed out')), Math.max(1, options.deadline - Date.now()));
+  timer.unref();
+  let completed;
+  const completion = new Promise(resolve => { completed = resolve; });
+  if (owners.size < MAX_PENDING_OWNERS) owners.set(identity, completion);
+  const finish = () => {
+    clearTimeout(timer);
+    if (owners.get(identity) === completion) owners.delete(identity);
+    completed();
+  };
+  const store = async value => {
+    try {
+      throwIfAborted(signal);
+      if (value === null) { await release(target, key, lease); return; }
+      const bytes = bufferValue(value);
+      if (bytes.length > MAX_CACHE_VALUE_BYTES) {
+        await release(target, key, lease);
+        return;
+      }
+      // A failed or superseded commit never replays the producer (which may
+      // perform an explicitly cached POST). Return the successful origin value.
+      try {
+        const metadata = options.resolveMetadata?.();
+        if (metadata?.externalCache) { await release(target, key, lease); return; }
+        const result = await rpc(target, { op: 'commit', key, lease, value: bytes.toString('base64'), revalidate: options.revalidate,
+          ...(metadata ? { tags: validateTags(metadata.tags), paths: metadata.paths || [], revalidate: validateRevalidate(metadata.revalidate, { allowZero: true }), expire: metadata.expire } : {}) }, signal);
+        if (!result.stored) await release(target, key, lease);
+      } catch {
+        await release(target, key, lease);
+        throwIfAborted(signal);
+      }
+    } catch (error) {
+      await release(target, key, lease);
+      throw error;
+    }
+  };
+  try {
+    throwIfAborted(signal);
+    const result = await untilAborted(Promise.resolve().then(() => producer({ background: Boolean(options.background), signal })), signal);
+    if (result?.[DEFERRED_VALUE]) {
+      const fill = (async () => {
+        try { await store(await untilAborted(result.cacheValue, signal)); }
+        catch (error) {
+          await release(target, key, lease);
+          throw error;
+        } finally {
+          if (options.background) { try { await untilAborted(result.dispose?.(), signal); } catch {} }
+          finish();
+        }
+      })();
+      trackBackground(options.state, fill);
+      return result.value;
+    }
+    const bytes = bufferValue(result);
+    await store(bytes);
+    finish();
+    return bytes;
+  } catch (error) {
+    await release(target, key, lease);
+    finish();
+    throw error;
+  }
+}
+
+async function uncachedValue(producer, state, signal) {
+  const result = await producer({ background: false, signal, cache: false });
+  if (result?.[DEFERRED_VALUE]) {
+    // A fetch may already have started its bounded capture before discovering
+    // there is no cache service. Observe it without retaining the live response.
+    trackBackground(state, untilAborted(result.cacheValue, AbortSignal.timeout(WAIT_TIMEOUT_MS)));
+    return result.value;
+  }
+  return bufferValue(result);
+}
+
+async function cachedValue(key, producer, options = {}) {
+  if (typeof key !== 'string' || !/^[a-f\d]{64}$/.test(key)) throw new TypeError('Cache keys must be a SHA-256 hex digest');
+  const context = options.context || optionalRequestContext();
+  const state = cacheState(context);
+  const tags = validateTags(options.tags);
+  const paths = options.paths || getCachePaths(context);
+  const revalidate = validateRevalidate(options.revalidate);
+  trackStaticDependency({ tags, paths, revalidate }, context);
+  const signal = options.signal;
+  if (state) await state.invalidations;
+  throwIfAborted(signal);
+  if (options.incremental && (context?.cacheHandler || context?.manifest?.config?.cacheHandler)) {
+    return require('./incremental-cache.cjs').cachedIncrementalValue(key, producer, { ...options, context, tags, paths, revalidate });
+  }
+  const target = endpoint();
+  // Builds and standalone runtime use have no native cache server. Compute
+  // without claiming persistence; production workers always receive its URL.
+  if (!target) return uncachedValue(producer, state, signal);
+  const deadline = Date.now() + WAIT_TIMEOUT_MS;
+  while (true) {
+    throwIfAborted(signal);
+    if (Date.now() >= deadline) throw new Error('Timed out waiting for a PRNext data cache lease');
+    let entry;
+    try { entry = await rpc(target, { op: 'read', key, tags, paths, revalidate, forceFresh: Boolean(options.forceFresh || context?.staticState), ...(options.versioned ? { versioned: true } : {}) }, signal); }
+    catch (error) {
+      throwIfAborted(signal);
+      // A temporarily unavailable cache must not make an origin unavailable.
+      return uncachedValue(producer, state, signal);
+    }
+    if (options.versioned && (typeof entry.key !== 'string' || !/^[a-f\d]{64}$/.test(entry.key) || !Number.isSafeInteger(entry.generation) || entry.generation < 0)) throw new Error('Invalid PRNext versioned cache response');
+    const entryKey = options.versioned ? entry.key : key;
+    const produce = options.versioned ? info => producer({ ...info, generation: entry.generation }) : producer;
+    if (entry.state === 'fresh') return decodeValue(entry.value);
+    if (entry.state === 'stale') {
+      const bytes = decodeValue(entry.value);
+      if (entry.lease) {
+        if (owners.size >= MAX_PENDING_OWNERS) trackBackground(state, release(target, entryKey, entry.lease));
+        else trackBackground(state, compute(target, entryKey, entry.lease, produce, { revalidate, signal, state, background: true, deadline, resolveMetadata: options.resolveMetadata }));
+      }
+      return bytes;
+    }
+    if (entry.state === 'miss' && entry.lease) {
+      if (owners.size >= MAX_PENDING_OWNERS) { await release(target, entryKey, entry.lease); return uncachedValue(producer, state, signal); }
+      return compute(target, entryKey, entry.lease, produce, { revalidate, signal, state, deadline, resolveMetadata: options.resolveMetadata });
+    }
+    if (entry.state !== 'pending') throw new Error('Invalid PRNext data cache lease response');
+    const waitMs = Math.min(Math.max(Number(entry.retryAfterMs) || 20, 5), 100, deadline - Date.now());
+    const owner = owners.get(`${target.url}\n${entryKey}`);
+    if (owner) {
+      // Wait for local work, then read again so tags/path attachments and
+      // invalidation revisions are checked. Never share an uncacheable Response.
+      await Promise.race([owner.catch(() => {}), delay(waitMs, undefined, { signal })]);
+    } else await delay(waitMs, undefined, { signal });
+  }
+}
+
+function queueInvalidation(context, operation) {
+  const state = cacheState(context);
+  const target = endpoint();
+  const custom = Object.keys(context.cacheHandlers || context.manifest?.config?.cacheHandlers || {}).length > 0;
+  const incremental = context.cacheHandler || context.manifest?.config?.cacheHandler;
+  if (!target && !custom && !incremental) throw new Error('Cache invalidation requires a running PRNext server');
+  state.refresh = true;
+  state.invalidations = state.invalidations.then(async () => {
+    if (target) await rpc(target, { op: 'invalidate', ...operation });
+    if (custom) await require('./cache-handlers.cjs').invalidateHandlers(context, operation);
+    if (incremental) await require('./incremental-cache.cjs').invalidate(context, operation);
+  });
+  // Public invalidation functions return void. Retain errors for the next read
+  // or runtime flush without producing an unhandled rejection in the meantime.
+  void state.invalidations.catch(() => {});
+}
+async function flushCacheWork(context = optionalRequestContext()) {
+  const state = cacheState(context);
+  if (!state) return;
+  await state.invalidations;
+  while (state.pending.size) await Promise.all([...state.pending]);
+  await state.invalidations;
+}
+async function flushCacheInvalidations(context = optionalRequestContext()) {
+  const state = cacheState(context);
+  if (state) await state.invalidations;
+}
+
+module.exports = {
+  cacheGeneration, acquireExternalCacheLease, DEFERRED_VALUE,
+  MAX_CACHE_VALUE_BYTES, nativeFetch, cachedValue, deferredValue, createCacheState, cacheState,
+  flushCacheWork, flushCacheInvalidations, runCacheScope, inCacheScope, currentCacheScope, optionalRequestContext,
+  getCachePaths, normalizeCachePath, validateTags, validateRevalidate, queueInvalidation,
+};

package/compat/dist/shared/lib/app-router-context.shared-runtime.d.cts

@@ -0,0 +1,3 @@
+import type {Context} from 'react';
+import {useRouter} from '../../../navigation.cjs';
+export const AppRouterContext: Context<ReturnType<typeof useRouter> | null>;

package/compat/dist/shared/lib/router-context.d.cts

@@ -0,0 +1 @@
+export {RouterContext} from './router-context.shared-runtime.cjs';

package/compat/dist/shared/lib/router-context.shared-runtime.d.cts

@@ -0,0 +1,3 @@
+import type {Context} from 'react';
+import type {NextRouter} from '../../../router.cjs';
+export const RouterContext: Context<NextRouter | null>;

package/compat/document.cjs

@@ -0,0 +1,73 @@
+'use strict';
+const React = require('react');
+const DocumentContext = React.createContext(null);
+function context(value) {
+  if (!value) throw new Error('Html, Head, Main and NextScript from next/document must only be rendered in pages/_document');
+  return value;
+}
+function safeJSON(value) {
+  return JSON.stringify(value).replace(/[<>&\u2028\u2029]/g, character => ({ '<': '\\u003c', '>': '\\u003e', '&': '\\u0026', '\u2028': '\\u2028', '\u2029': '\\u2029' })[character]);
+}
+function Html(props) {
+  const state = context(React.useContext(DocumentContext));
+  state.rendered.add('Html');
+  return React.createElement('html', { lang: state.__NEXT_DATA__?.locale, ...props });
+}
+class Head extends React.Component {
+  static contextType = DocumentContext;
+  getCssLinks() {
+    const state = context(this.context);
+    return state.css.map(href => React.createElement('link', { key: href, rel: 'stylesheet', href,
+      nonce: this.props.nonce || state.nonce, crossOrigin: this.props.crossOrigin || state.crossOrigin }));
+  }
+  getScripts() {
+    const state = context(this.context);
+    return state.client ? [React.createElement('script', { key: state.client, type: 'module', src: state.client,
+      nonce: this.props.nonce || state.nonce, crossOrigin: this.props.crossOrigin || state.crossOrigin })] : [];
+  }
+  getFontLinks() {
+    const state = context(this.context);
+    return (state.fonts || []).map(font => React.createElement('link', { key: font.href, rel: 'preload', as: 'font',
+      href: font.href, type: font.type, crossOrigin: 'anonymous', nonce: this.props.nonce || state.nonce }));
+  }
+  render() {
+    const state = context(this.context);
+    state.rendered.add('Head');
+    const { children, nonce, crossOrigin, ...props } = this.props;
+    state.headNonce = nonce || state.nonce;
+    state.headCrossOrigin = crossOrigin || state.crossOrigin;
+    return React.createElement('head', props, state.head, children, this.getFontLinks(), this.getCssLinks(),
+      React.createElement('prnext-document-script-target'), this.getScripts(), state.styles);
+  }
+}
+function Main() {
+  const state = context(React.useContext(DocumentContext));
+  state.rendered.add('Main');
+  return React.createElement('prnext-document-body-target');
+}
+class NextScript extends React.Component {
+  static contextType = DocumentContext;
+  static getInlineScriptSource(state) { return safeJSON(state.__NEXT_DATA__); }
+  render() {
+    const state = context(this.context);
+    state.rendered.add('NextScript');
+    const nonce = this.props.nonce || state.nonce;
+    const crossOrigin = this.props.crossOrigin || state.crossOrigin;
+    const payload = `window.__PRNEXT_DATA__=JSON.parse(${safeJSON(JSON.stringify(state.payload))});`;
+    return React.createElement('script', { nonce, crossOrigin, dangerouslySetInnerHTML: { __html: payload } });
+  }
+}
+class Document extends React.Component {
+  static getInitialProps(ctx) { return ctx.defaultGetInitialProps(ctx); }
+  render() {
+    return React.createElement(Html, null, React.createElement(Head, { nonce: this.props.nonce }),
+      React.createElement('body', null, React.createElement(Main), React.createElement(NextScript, { nonce: this.props.nonce })));
+  }
+}
+module.exports = Document;
+module.exports.default = Document;
+module.exports.Html = Html;
+module.exports.Head = Head;
+module.exports.Main = Main;
+module.exports.NextScript = NextScript;
+module.exports.DocumentContext = DocumentContext;

package/compat/document.d.cts

@@ -0,0 +1,41 @@
+import { Component, type ComponentType, type ReactElement, type ReactNode, type HTMLAttributes, type HtmlHTMLAttributes } from 'react';
+import type { AppProps, NextPageContext } from './index.d.ts';
+
+export type Enhancer<C> = (Component: C) => C;
+export type ComponentsEnhancer = {
+  enhanceApp?: Enhancer<ComponentType<AppProps<any>>>;
+  enhanceComponent?: Enhancer<ComponentType<any>>;
+} | Enhancer<ComponentType<any>>;
+export interface RenderPageResult { html: string; head?: Array<ReactElement | null> }
+export interface DocumentInitialProps extends RenderPageResult {
+  styles?: ReactElement[] | Iterable<ReactNode> | ReactElement;
+}
+export type RenderPage = (options?: ComponentsEnhancer) => DocumentInitialProps | Promise<DocumentInitialProps>;
+export interface DocumentContext extends NextPageContext {
+  renderPage: RenderPage;
+  defaultGetInitialProps(context: DocumentContext, options?: { nonce?: string }): Promise<DocumentInitialProps>;
+}
+export interface DocumentProps extends DocumentInitialProps {
+  __NEXT_DATA__: { props: { pageProps: any }; page: string; query: NextPageContext['query']; buildId?: string; assetPrefix?: string; isFallback?: boolean; gsp?: boolean; gssp?: boolean };
+  assetPrefix: string;
+  dangerousAsPath: string;
+  isDevelopment: boolean;
+  nonce?: string;
+  crossOrigin?: 'anonymous' | 'use-credentials' | '';
+}
+export interface OriginProps { nonce?: string; crossOrigin?: 'anonymous' | 'use-credentials' | ''; children?: ReactNode }
+export function Html(props: HtmlHTMLAttributes<HTMLHtmlElement>): ReactElement;
+export class Head extends Component<OriginProps & HTMLAttributes<HTMLHeadElement>> {
+  getCssLinks(): ReactElement[];
+  getScripts(): ReactElement[];
+  render(): ReactElement;
+}
+export function Main(): ReactElement;
+export class NextScript extends Component<OriginProps> {
+  static getInlineScriptSource(context: Readonly<{ __NEXT_DATA__: DocumentProps['__NEXT_DATA__'] }>): string;
+  render(): ReactElement;
+}
+export default class Document<Props = {}> extends Component<DocumentProps & Props> {
+  static getInitialProps(context: DocumentContext): Promise<DocumentInitialProps>;
+  render(): ReactElement;
+}