@thomas.f/prnext 0.1.0-alpha.1

package/compat/incremental-cache.cjs

@@ -0,0 +1,186 @@
+'use strict';
+const path = require('node:path');
+const fs = require('node:fs');
+const { pathToFileURL } = require('node:url');
+const { softTags } = require('./cache-handlers.cjs');
+const { trackStaticDependency } = require('./static-generation.cjs');
+const MAX_BYTES = 2 * 1024 * 1024;
+const modules = new Map();
+const instances = new WeakMap();
+let ownersCount = 0;
+
+function configured(context) { return context?.cacheHandler || context?.manifest?.config?.cacheHandler; }
+function outside(callback) { return require('./headers.cjs').runWithoutRequestContext(callback); }
+function wait(promise, signal, milliseconds = 5000) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => finish(reject, new Error('Incremental cache handler timed out')), milliseconds);
+    timer.unref();
+    const abort = () => finish(reject, signal.reason);
+    function finish(callback, value) { clearTimeout(timer); signal?.removeEventListener('abort', abort); callback(value); }
+    signal?.addEventListener('abort', abort, { once: true });
+    if (signal?.aborted) abort();
+    Promise.resolve(promise).then(value => finish(resolve, value), error => finish(reject, error));
+  });
+}
+async function invoke(handler, method, args, context) {
+  return wait(outside(() => Promise.resolve().then(() => handler[method](...args))), context?.signal);
+}
+async function load(context) {
+  const source = configured(context);
+  if (!source) return undefined;
+  let pending = instances.get(context);
+  if (pending) return pending;
+  const root = path.resolve(context.distDir || '');
+  const filename = path.resolve(root, source);
+  if (!context.distDir || !source.startsWith('server/') || !filename.startsWith(root + path.sep)) throw new Error('Invalid incremental cache handler path');
+  let record = modules.get(filename);
+  if (!record) {
+    record = { module: outside(() => import(pathToFileURL(filename).href)), revision: 0, owners: new Map() };
+    if (modules.size >= 32) modules.delete(modules.keys().next().value);
+    modules.set(filename, record);
+  }
+  pending = (async () => {
+    const imported = await wait(record.module, context.signal);
+    const Constructor = imported.default;
+    if (typeof Constructor !== 'function') throw new TypeError('cacheHandler must export a constructor');
+    const handler = outside(() => new Constructor({
+      dev: context.production === false, fs: { ...fs.promises, readFileSync: fs.readFileSync, existsSync: fs.existsSync },
+      flushToDisk: true, serverDistDir: path.join(root, 'server'), revalidatedTags: [],
+      maxMemoryCacheSize: context.cacheMaxMemorySize ?? context.manifest?.config?.cacheMaxMemorySize,
+      _requestHeaders: Object.fromEntries(new Headers(context.headers || {})), fetchCacheKeyPrefix: '',
+    }));
+    if (['get', 'set', 'revalidateTag'].some(name => typeof handler[name] !== 'function')) throw new TypeError('cacheHandler must implement get, set and revalidateTag');
+    if (handler.resetRequestCache !== undefined) {
+      if (typeof handler.resetRequestCache !== 'function') throw new TypeError('cacheHandler.resetRequestCache must be a function');
+      await invoke(handler, 'resetRequestCache', [], context);
+    }
+    return { handler, record };
+  })();
+  instances.set(context, pending);
+  return pending;
+}
+async function getEntry(key, kind, context, options = {}) {
+  const { handler } = await load(context);
+  return invoke(handler, 'get', [key, { kind, ...options }], context);
+}
+async function setEntry(key, value, context, options = {}) {
+  const { handler } = await load(context);
+  return invoke(handler, 'set', [key, value, { ...options }], context);
+}
+async function invalidate(context, operation) {
+  const { handler, record } = await load(context);
+  record.revision++;
+  const tags = [...(operation.tags || []), ...(operation.paths || []).map(value => {
+    const separator = value.indexOf(':');
+    return '_N_T_' + value.slice(separator + 1).replace(/\/$/, '') + '/' + value.slice(0, separator);
+  })];
+  const durations = operation.mode === 'expire' ? { expire: 0 } : operation.expire === undefined ? undefined : { expire: operation.expire };
+  await invoke(handler, 'revalidateTag', [[...new Set(tags)], durations], context);
+}
+function fresh(entry, revalidate) {
+  const timestamp = entry?.lastModified;
+  if (!Number.isFinite(timestamp) || timestamp < 0 || timestamp > Date.now() + 60_000) return false;
+  const stored = entry.value?.revalidate;
+  const storedTtl = typeof stored === 'number' && Number.isFinite(stored) && stored >= 0 ? stored : Infinity;
+  const ttl = Math.min(revalidate === false ? Infinity : revalidate, storedTtl);
+  return Date.now() - timestamp < ttl * 1000;
+}
+
+/** Keep streaming fetch responses live while only bounded captured bytes enter storage. */
+async function cachedIncrementalValue(key, producer, options) {
+  const cache = require('./data-cache.cjs');
+  const { context, incremental } = options;
+  const signal = options.signal || context.signal;
+  const state = cache.cacheState(context);
+  await state.invalidations;
+  signal?.throwIfAborted();
+  const { handler, record } = await load(context);
+  const tags = cache.validateTags(options.tags);
+  const implicit = softTags(context);
+  const revalidate = options.revalidate == null ? false : options.revalidate;
+  const getContext = { kind: 'FETCH', fetchCache: true, tags, softTags: implicit,
+    revalidate, fetchUrl: incremental.url || '', fetchIdx: 0 };
+  // PPR artifacts cannot hide invalidations maintained by an external backend.
+  if (context.cacheComponents) trackStaticDependency({ externalCache: true }, context);
+  let entry, bytes;
+  try {
+    entry = await invoke(handler, 'get', [key, getContext], context);
+    if (entry?.value?.kind === 'FETCH' && typeof entry.lastModified === 'number' && Number.isFinite(entry.lastModified)) {
+      bytes = incremental.decode(entry.value);
+      if (!Buffer.isBuffer(bytes) || bytes.length > MAX_BYTES) bytes = undefined;
+    }
+  } catch { signal?.throwIfAborted(); }
+  const stale = bytes && !fresh(entry, revalidate);
+  if (bytes && !stale) return bytes;
+  const existing = record.owners.get(key);
+  if (options.join !== false && (!bytes || options.forceFresh || context.staticState) && existing?.revision === record.revision) {
+    // Read the backend again after joining: it owns cross-instance invalidation.
+    await wait(existing.done, signal, 25_000);
+    if (options.join !== false) return cachedIncrementalValue(key, producer, { ...options, join: false });
+  }
+  if (stale && !options.forceFresh && !context.staticState && existing?.revision === record.revision) return bytes;
+  const background = Boolean(stale && !options.forceFresh && !context.staticState);
+  const revision = record.revision;
+  let complete;
+  const owner = { revision, done: new Promise(resolve => { complete = resolve; }) };
+  if (ownersCount < 64) { record.owners.set(key, owner); ownersCount++; }
+  let lease;
+  const cleanup = async () => {
+    if (owner.finished) return;
+    owner.finished = true;
+    try { await lease?.release(); } finally {
+    if (record.owners.get(key) === owner) record.owners.delete(key);
+    if (owner.tracked) ownersCount--;
+    complete();
+    }
+  };
+  owner.tracked = record.owners.get(key) === owner;
+  const store = async value => {
+    if (value == null || revision !== record.revision) return;
+    if (!(value instanceof Uint8Array) || value.byteLength > MAX_BYTES) return;
+    if (lease && !await lease.valid()) return;
+    const data = incremental.encode(Buffer.from(value));
+    const setContext = { ...getContext, tags: [...new Set([...tags, ...implicit])], cacheControl: { revalidate } };
+    try {
+      await invoke(handler, 'set', [key, { kind: 'FETCH', data, revalidate: revalidate === false ? 31536000 : revalidate }, setContext], context);
+      // A mutation in any local worker can revoke the native lease while the
+      // asynchronous backend write is finishing. Remove a possibly old entry.
+      if (revision !== record.revision || (lease && !await lease.valid())) await invoke(handler, 'set', [key, null, setContext], context);
+    }
+    catch { signal?.throwIfAborted(); }
+  };
+  const work = (async () => {
+    try {
+      lease = await cache.acquireExternalCacheLease(key, signal);
+      if (lease) {
+        // Even an immediately granted lease may follow a producer that finished
+        // between our first backend read and this native admission.
+        let shared;
+        try {
+          const latest = await invoke(handler, 'get', [key, getContext], context);
+          if (latest?.value?.kind === 'FETCH' && fresh(latest, revalidate)) {
+            shared = incremental.decode(latest.value);
+            if (!Buffer.isBuffer(shared) || shared.length > MAX_BYTES) shared = undefined;
+          }
+        } catch { signal?.throwIfAborted(); }
+        if (shared) { await cleanup(); return shared; }
+      }
+      const result = await wait(Promise.resolve().then(() => producer({ background, signal })), signal, 25_000);
+      if (result?.[cache.DEFERRED_VALUE]) {
+        const fill = (async () => {
+          try { await store(await wait(result.cacheValue, signal, 25_000)); }
+          finally { try { if (background) await wait(result.dispose?.(), signal, 1000); } finally { await cleanup(); } }
+        })();
+        const observed = fill.catch(() => {});
+        state.pending.add(observed); void observed.finally(() => state.pending.delete(observed));
+        return result.value;
+      }
+      try { await store(result); return result; } finally { await cleanup(); }
+    } catch (error) { await cleanup(); throw error; }
+  })();
+  if (!background) return work;
+  const observed = work.catch(async error => { try { await error?.dispose?.(); } catch {} });
+  state.pending.add(observed); void observed.finally(() => state.pending.delete(observed));
+  return bytes;
+}
+module.exports = { configured, load, invoke, wait, getEntry, setEntry, invalidate, cachedIncrementalValue };

package/compat/index.d.ts

@@ -0,0 +1,159 @@
+/// <reference path="./fetch.d.cts" />
+import type { ComponentType } from 'react';
+import type { IncomingMessage, ServerResponse } from 'node:http';
+export type { Metadata, Viewport, ResolvingMetadata, ResolvingViewport, MetadataRoute } from './metadata.cjs';
+
+export interface InstantSample {
+  cookies?: Array<{name: string; value: string | null}>;
+  headers?: Array<[string, string | null]>;
+  params?: Record<string, string | string[]>;
+  searchParams?: Record<string, string | string[] | null>;
+}
+export type InstantConfig = boolean | { level?: 'warning' | 'experimental-error'; unstable_samples?: InstantSample[]; unstable_disableValidation?: true; unstable_disableDevValidation?: true; unstable_disableBuildValidation?: true };
+
+export type TurbopackCondition = 'browser' | 'foreign' | 'development' | 'production' | 'node' | 'edge-light'
+  | {all: TurbopackCondition[]} | {any: TurbopackCondition[]} | {not: TurbopackCondition}
+  | {path: string | RegExp; content?: RegExp} | {path?: string | RegExp; content: RegExp};
+export interface TurbopackRule {
+  loaders: Array<string | {loader: string; options?: Record<string, unknown>}>;
+  as?: '*.js' | '*.jsx';
+  condition?: TurbopackCondition;
+}
+
+export type PreviewData = string | false | object | undefined;
+export type ParsedUrlQuery = Record<string, string | string[] | undefined>;
+export type Redirect = ({ destination: string; permanent: boolean; statusCode?: never } | { destination: string; statusCode: 301 | 302 | 303 | 307 | 308; permanent?: never }) & { basePath?: false };
+export type DataResult<Props> = { props: Props | Promise<Props> } | { notFound: true } | { redirect: Redirect };
+export interface LocaleInfo { locale?: string; locales?: string[]; defaultLocale?: string; }
+export interface GetServerSidePropsContext<Params extends ParsedUrlQuery = ParsedUrlQuery> extends LocaleInfo {
+  req: IncomingMessage & { cookies: Record<string, string>; query: ParsedUrlQuery };
+  res: ServerResponse;
+  params?: Params;
+  query: ParsedUrlQuery;
+  resolvedUrl: string;
+  preview: boolean;
+  previewData?: PreviewData;
+  draftMode: boolean;
+}
+export type GetServerSideProps<Props extends Record<string, unknown> = Record<string, unknown>, Params extends ParsedUrlQuery = ParsedUrlQuery> = (context: GetServerSidePropsContext<Params>) => Promise<DataResult<Props>> | DataResult<Props>;
+export interface GetStaticPropsContext<Params extends ParsedUrlQuery = ParsedUrlQuery> extends LocaleInfo {
+  params?: Params;
+  preview: boolean;
+  previewData?: PreviewData;
+  draftMode: boolean;
+  revalidateReason: 'build' | 'stale' | 'on-demand';
+}
+export type GetStaticProps<Props extends Record<string, unknown> = Record<string, unknown>, Params extends ParsedUrlQuery = ParsedUrlQuery> = (context: GetStaticPropsContext<Params>) => Promise<DataResult<Props> & { revalidate?: number | false }> | (DataResult<Props> & { revalidate?: number | false });
+export type GetStaticPaths<Params extends ParsedUrlQuery = ParsedUrlQuery> = (context: {locales?: string[]; defaultLocale?: string}) => Promise<{ paths: Array<string | { params: Params; locale?: string }>; fallback: boolean | 'blocking' }> | { paths: Array<string | { params: Params; locale?: string }>; fallback: boolean | 'blocking' };
+export type InferGetServerSidePropsType<T extends (...args: any[]) => any> = Awaited<Extract<Awaited<ReturnType<T>>, { props: any }>['props']>;
+export type InferGetStaticPropsType<T extends (...args: any[]) => any> = InferGetServerSidePropsType<T>;
+export interface NextApiRequest extends IncomingMessage {
+  query: ParsedUrlQuery;
+  cookies: Record<string, string>;
+  body: any;
+  draftMode: boolean;
+  preview: boolean;
+  previewData?: PreviewData;
+}
+/** Pages API responses can stream; socket upgrades are not implemented. */
+export type NextApiResponse<T = any> = Pick<ServerResponse, 'statusCode' | 'statusMessage' | 'headersSent' | 'getHeader' | 'getHeaders' | 'getHeaderNames' | 'hasHeader' | 'removeHeader' | 'write' | 'end' | 'on' | 'once' | 'writableEnded'> & {
+  setHeader(name: string, value: number | string | readonly string[]): NextApiResponse<T>;
+  appendHeader(name: string, value: string | readonly string[]): NextApiResponse<T>;
+  writeHead(statusCode: number, headers?: import('node:http').OutgoingHttpHeaders): NextApiResponse<T>;
+  writeHead(statusCode: number, statusMessage?: string, headers?: import('node:http').OutgoingHttpHeaders): NextApiResponse<T>;
+  status(statusCode: number): NextApiResponse<T>;
+  json(body: T): void;
+  send(body: T | string | Buffer | Uint8Array): void;
+  redirect(destination: string): void;
+  redirect(statusCode: number, destination: string): void;
+  revalidate(path: string, options?: { unstable_onlyGenerated?: boolean }): Promise<void>;
+  setPreviewData(data: PreviewData, options?: { maxAge?: number; path?: string }): NextApiResponse<T>;
+  setDraftMode(options: { enable: boolean }): NextApiResponse<T>;
+  clearPreviewData(options?: { path?: string }): NextApiResponse<T>;
+};
+export type NextApiHandler<T = any> = (req: NextApiRequest, res: NextApiResponse<T>) => void | Promise<void>;
+export interface NextPageContext extends LocaleInfo {
+  err?: (Error & { statusCode?: number }) | null;
+  req?: IncomingMessage;
+  res?: ServerResponse;
+  pathname: string;
+  query: ParsedUrlQuery;
+  asPath?: string;
+  AppTree: ComponentType<AppInitialProps & Record<string, any>>;
+}
+export type NextPage<Props = Record<string, never>, InitialProps = Props> = ComponentType<Props> & {
+  getInitialProps?(context: NextPageContext): InitialProps | Promise<InitialProps>;
+};
+export interface AppProps<Props = Record<string, unknown>> {
+  Component: NextPage<Props, any>;
+  pageProps: Props;
+  router: import('./router.cjs').PRNextRouter;
+}
+export interface AppInitialProps<Props = any> { pageProps: Props }
+export interface AppContext {
+  Component: NextPage<any, any>;
+  router: import('./router.cjs').PRNextRouter;
+  ctx: NextPageContext;
+  AppTree: ComponentType<any>;
+}
+export type AppType<Props = {}> = ComponentType<AppProps<any> & Props> & {
+  getInitialProps?(context: AppContext): AppInitialProps & Props | Promise<AppInitialProps & Props>;
+};
+export type RouteCondition = { type: 'header' | 'cookie' | 'query'; key: string; value?: string } | { type: 'host'; value: string; key?: never };
+export interface CustomRoute {
+  source: string;
+  has?: RouteCondition[];
+  missing?: RouteCondition[];
+  basePath?: false;
+  locale?: false;
+}
+export interface Header extends CustomRoute { headers: Array<{ key: string; value: string }> }
+export interface Rewrite extends CustomRoute { destination: string }
+export type ConfigRedirect = CustomRoute & Redirect;
+/** Implemented project options. Unsupported behavior-changing options fail the build. */
+export interface NextConfig {
+  /** Next dev page-retention hints; PRNext builds all routes without that eviction queue. */
+  onDemandEntries?: { maxInactiveAge?: number; pagesBufferLength?: number };
+  i18n?: { locales: string[]; defaultLocale: string; localeDetection?: boolean; domains?: Array<{domain: string; defaultLocale: string; locales?: string[]; http?: boolean}> };
+  webpack?: (config: import('webpack').Configuration, context: { buildId: string; dev: boolean; isServer: boolean; nextRuntime?: 'nodejs' | 'edge'; webpack: typeof import('webpack'); defaultLoaders: {babel: {loader: string}} }) => import('webpack').Configuration | Promise<import('webpack').Configuration>;
+  turbopack?: { root?: string; rules?: Record<string, TurbopackRule | TurbopackRule[]>; resolveAlias?: Record<string, string | { browser: string }>; resolveExtensions?: string[] };
+  images?: import('./image.cjs').ImageConfig;
+  pageExtensions?: string[];
+  reactStrictMode?: boolean;
+  cacheComponents?: boolean;
+  cacheLife?: Record<string, import('./cache.cjs').CacheLife>;
+  transpilePackages?: string[];
+  serverExternalPackages?: string[];
+  sassOptions?: {
+    additionalData?: string | ((source: string, context: { resourcePath: string; rootContext: string }) => string | Promise<string>);
+    includePaths?: string[];
+    loadPaths?: string[];
+    implementation?: 'sass' | 'sass-embedded';
+    [option: string]: unknown;
+  };
+  experimental?: { nextScriptWorkers?: boolean; serverActions?: true | { allowedOrigins?: string[]; bodySizeLimit?: number | string } };
+  trailingSlash?: boolean;
+  skipTrailingSlashRedirect?: boolean;
+  skipMiddlewareUrlNormalize?: boolean;
+  skipProxyUrlNormalize?: boolean;
+  cacheHandlers?: Record<string, string | undefined>;
+  cacheHandler?: string;
+  cacheMaxMemorySize?: number;
+  distDir?: string;
+  output?: 'standalone' | 'export';
+  outputFileTracingRoot?: string;
+  outputFileTracingIncludes?: Record<string, string[]>;
+  outputFileTracingExcludes?: Record<string, string[]>;
+  basePath?: string;
+  assetPrefix?: string;
+  env?: Record<string, string | undefined>;
+  compress?: boolean;
+  poweredByHeader?: boolean;
+  productionBrowserSourceMaps?: boolean;
+  generateBuildId?: () => string | null | Promise<string | null>;
+  headers?: () => Header[] | Promise<Header[]>;
+  redirects?: () => ConfigRedirect[] | Promise<ConfigRedirect[]>;
+  rewrites?: () => Rewrite[] | { beforeFiles?: Rewrite[]; afterFiles?: Rewrite[]; fallback?: Rewrite[] } | Promise<Rewrite[] | { beforeFiles?: Rewrite[]; afterFiles?: Rewrite[]; fallback?: Rewrite[] }>;
+}
+export type PRNextConfig = NextConfig;
+export type { DocumentContext, DocumentInitialProps, DocumentProps } from './document.cjs';

package/compat/instant-samples.cjs

@@ -0,0 +1,39 @@
+'use strict';
+const record = value => value && typeof value === 'object' && !Array.isArray(value);
+const text = value => typeof value === 'string' && value.length <= 8192;
+const values = value => text(value) || Array.isArray(value) && value.length <= 128 && value.every(text);
+function validSamples(samples) {
+  return Array.isArray(samples) && samples.length > 0 && samples.length <= 32 && Buffer.byteLength(JSON.stringify(samples)) <= 128 * 1024 && samples.every(sample => record(sample) && Object.entries(sample).every(([name,value]) => {
+    if (name === 'cookies') return Array.isArray(value) && value.length <= 128 && value.every(item => record(item) && Object.keys(item).every(key=>['name','value'].includes(key)) && text(item.name) && /^[!#$%&'*+.^_`|~\w-]+$/.test(item.name) && (item.value === null || text(item.value)));
+    if (name === 'headers') return Array.isArray(value) && value.length <= 128 && value.every(item => Array.isArray(item) && item.length === 2 && text(item[0]) && /^[!#$%&'*+.^_`|~\w-]+$/.test(item[0]) && (item[1] === null || text(item[1]) && !/[\r\n\0]/.test(item[1])));
+    if (name === 'params' || name === 'searchParams') return record(value) && Object.keys(value).length <= 128 && Object.entries(value).every(([key,value])=>text(key) && (values(value) || name === 'searchParams' && value === null));
+    return false;
+  }));
+}
+function missing(request, kind, name) {
+  const error = Object.assign(new Error(`Route ${request.routePattern}: instant.unstable_samples does not declare ${kind} ${JSON.stringify(name)}. Supply a value${kind === 'params' ? '' : ' or null for absence'}.`),{code:'PRNEXT_INSTANT_SAMPLE'});
+  if(request.staticState) request.staticState.error ||= error;
+  throw error;
+}
+function sampleMethods(request,kind,target) {
+  const sample = request.instantSample;
+  const names = new Set((sample[kind] || []).map(item=>kind === 'cookies' ? item.name : item[0].toLowerCase()));
+  if(kind === 'headers' && sample.cookies)names.add('cookie');
+  return new Proxy(target,{get(value,key){
+    const method=Reflect.get(value,key,value);
+    if(['get','has','getAll'].includes(key))return argument=>{
+      const name=typeof argument === 'object' ? argument.name : argument;
+      if(name !== undefined && !names.has(kind === 'headers' ? String(name).toLowerCase() : name))missing(request,kind,name);
+      return method.call(value,argument);
+    };
+    return typeof method === 'function' ? method.bind(value) : method;
+  }});
+}
+function sampleObject(request,kind,values) {
+  const declared=request.instantSample[kind] || {};
+  return new Proxy(values,{get(target,key,receiver){
+    if(typeof key === 'string' && !['then','toJSON'].includes(key) && !Object.hasOwn(declared,key))missing(request,kind,key);
+    return Reflect.get(target,key,receiver);
+  },has(target,key){if(typeof key==='string'&&!Object.hasOwn(declared,key))missing(request,kind,key);return Reflect.has(target,key);}});
+}
+module.exports={validSamples,sampleMethods,sampleObject};

package/compat/instant.cjs

@@ -0,0 +1,13 @@
+'use strict';
+
+// Shell validation is separate: these options only control navigation probes.
+function instantEnabled(config, production) {
+  if (config === false) return false;
+  if (config && typeof config === 'object') {
+    if (config.unstable_disableValidation || (production ? config.unstable_disableBuildValidation : config.unstable_disableDevValidation)) return false;
+    return !production || config.level === 'experimental-error';
+  }
+  return !production;
+}
+
+module.exports = { instantEnabled };

package/compat/link.cjs

@@ -0,0 +1,68 @@
+'use client';
+'use strict';
+const React = require('react');
+const { formatUrl, RouterContext } = require('./router.cjs');
+const { AppRouterContext } = require('./app-context.cjs');
+const { addBasePath, hasBasePath, normalizeTrailingSlash } = require('./paths.cjs');
+const { localizedHref } = require('./locale.cjs');
+
+const Link = React.forwardRef(function Link({ href, as, children, replace, scroll, shallow, prefetch,
+  locale, legacyBehavior, passHref, onClick, onNavigate, onMouseEnter, onTouchStart, ...props }, ref) {
+  const app = React.useContext(AppRouterContext);
+  const pages = React.useContext(RouterContext);
+  const anchorRef = React.useRef(null);
+  const setRef = React.useCallback(node => { anchorRef.current = node; if (typeof ref === 'function') ref(node); else if (ref) ref.current = node; }, [ref]);
+  const target = localizedHref(formatUrl(as || href), pages, locale);
+  const basePath = app?.basePath || pages?.basePath || '';
+  const policy = app || pages || {};
+  const mounted = basePath && /^\/(?:[?#]|$)/.test(target) && !policy.trailingSlash && !policy.skipTrailingSlashRedirect ? `${basePath}${target.slice(1)}`
+    : target.startsWith('//') ? target : addBasePath(target, basePath);
+  const publicTarget = normalizeTrailingSlash(mounted, policy);
+  const source = formatUrl(href);
+  const requestPrefetch = React.useCallback(() => {
+    if (app?.router.partialPrefetch && prefetch !== false && process.env.NODE_ENV === 'production') app.router.prefetch(target);
+    if (!app && pages && process.env.NODE_ENV === 'production') void pages.prefetch(source, as ? target : undefined, {locale}).catch(() => {});
+  }, [app, pages, source, target, as, prefetch]);
+  React.useEffect(() => {
+    if ((app ? !app.router.partialPrefetch : !pages) || prefetch === false || process.env.NODE_ENV !== 'production' || typeof IntersectionObserver === 'undefined' || !anchorRef.current) return;
+    const observer = new IntersectionObserver(entries => {
+      if (entries.some(entry => entry.isIntersecting)) { observer.disconnect(); requestPrefetch(); }
+    }, { rootMargin: '200px' });
+    observer.observe(anchorRef.current);
+    return () => observer.disconnect();
+  }, [app, pages, prefetch, requestPrefetch]);
+  if (/^[\s\u0000-\u001f]*javascript:/i.test(target.replace(/[\r\n\t]/g, ''))) {
+    throw new Error('Link does not permit javascript: URLs');
+  }
+  function click(event) {
+    onClick?.(event);
+    const anchor = event.currentTarget;
+    const anchorTarget = anchor?.getAttribute('target') || props.target;
+    if (event.defaultPrevented || event.button !== 0 || event.metaKey || event.ctrlKey || event.shiftKey || event.altKey ||
+        (anchorTarget && anchorTarget.toLowerCase() !== '_self') || anchor?.hasAttribute('download') || props.download !== undefined) return;
+    const destination = new URL(publicTarget, window.location.href);
+    if (destination.origin !== window.location.origin || !hasBasePath(destination.pathname, basePath) || !['http:', 'https:'].includes(destination.protocol)) return;
+    let prevented = false;
+    onNavigate?.({ preventDefault() { prevented = true; event.preventDefault(); } });
+    if (prevented) return;
+    if (app) {
+      event.preventDefault();
+      app.router[replace ? 'replace' : 'push'](target, { scroll });
+    } else if (pages) {
+      event.preventDefault();
+      void pages[replace ? 'replace' : 'push'](href, as, { scroll, shallow, locale }).catch(error => console.error(error));
+    } else if (replace) { event.preventDefault(); window.location.replace(publicTarget); }
+  }
+  function hover(event) { onMouseEnter?.(event); requestPrefetch(); }
+  function touch(event) { onTouchStart?.(event); requestPrefetch(); }
+  if (legacyBehavior) {
+    const child = React.Children.only(children);
+    return React.cloneElement(child, { ...props, href: publicTarget, ref: setRef,
+      onMouseEnter(event) { child.props.onMouseEnter?.(event); hover(event); },
+      onTouchStart(event) { child.props.onTouchStart?.(event); touch(event); },
+      onClick(event) { child.props.onClick?.(event); if (!event.defaultPrevented) click(event); } });
+  }
+  return React.createElement('a', { ...props, href: publicTarget, ref: setRef, onClick: click, onMouseEnter: hover, onTouchStart: touch }, children);
+});
+module.exports = Link;
+module.exports.default = Link;

package/compat/link.d.cts

@@ -0,0 +1,17 @@
+import type { AnchorHTMLAttributes, ForwardRefExoticComponent, ReactNode, RefAttributes } from 'react';
+import type { UrlObject } from './router.cjs';
+export interface LinkProps extends Omit<AnchorHTMLAttributes<HTMLAnchorElement>, 'href'> {
+  href: string | UrlObject;
+  as?: string | UrlObject;
+  replace?: boolean;
+  scroll?: boolean;
+  shallow?: boolean;
+  prefetch?: boolean | null;
+  locale?: string | false;
+  legacyBehavior?: boolean;
+  passHref?: boolean;
+  children?: ReactNode;
+  onNavigate?: (event: { preventDefault(): void }) => void;
+}
+declare const Link: ForwardRefExoticComponent<LinkProps & RefAttributes<HTMLAnchorElement>>;
+export default Link;

package/compat/locale.cjs

@@ -0,0 +1,30 @@
+'use strict';
+function localePath(pathname, i18n) {
+  if (!i18n) return { pathname, locale: undefined };
+  const first = pathname.split(/[/?#]/)[1];
+  const locale = i18n.locales.find(value => value.toLowerCase() === first?.toLowerCase());
+  const rest = locale ? pathname.slice(first.length + 1) : pathname;
+  return { pathname: rest.startsWith('/') ? rest : '/' + rest, locale: locale || i18n.defaultLocale };
+}
+function withLocale(pathname, locale, defaultLocale) {
+  return !locale || locale === defaultLocale ? pathname : '/' + locale + (pathname === '/' ? '' : pathname);
+}
+function localizedHref(href, router, selected) {
+  if (!router?.i18n || selected === false || !href.startsWith('/') || href.startsWith('//')) return href;
+  const i18n = router.i18n;
+  const locale = selected || router.locale || i18n.defaultLocale;
+  if (!i18n.locales.includes(locale)) throw new Error(`Unknown locale: ${locale}`);
+  const url = new URL(href, 'http://prnext.local');
+  const base = router.basePath || '';
+  if (base && (url.pathname === base || url.pathname.startsWith(base + '/'))) url.pathname = url.pathname.slice(base.length) || '/';
+  const parsed = localePath(url.pathname, i18n);
+  const explicit = parsed.pathname !== url.pathname;
+  const chosen = selected || (explicit ? parsed.locale : locale);
+  const domain = i18n.domains?.find(value => value.defaultLocale === chosen || value.locales?.includes(chosen));
+  const host = router.domain;
+  const current = i18n.domains?.find(value => value.domain.toLowerCase() === host?.toLowerCase());
+  const prefix = domain && current && domain.domain !== current.domain ? `${domain.http ? 'http' : 'https'}://${domain.domain}` : '';
+  const defaultLocale = (prefix ? domain?.defaultLocale : current?.defaultLocale) || router.defaultLocale || i18n.defaultLocale;
+  return prefix + base + withLocale(parsed.pathname, chosen, defaultLocale) + url.search + url.hash;
+}
+module.exports = { localePath, withLocale, localizedHref };

package/compat/metadata.d.cts

@@ -0,0 +1,77 @@
+type OneOrMany<T> = T | T[];
+type Url = string | URL;
+type Title = string | { default: string; template: string; absolute?: string } | { absolute: string; template?: string };
+type UrlDescriptor = { url: Url; title?: string };
+type Image = Url | { url: Url; secureUrl?: Url; width?: string | number; height?: string | number; alt?: string; type?: string };
+type Robots = { index?: boolean; follow?: boolean; noarchive?: boolean; nosnippet?: boolean; noimageindex?: boolean; nocache?: boolean; notranslate?: boolean; indexifembedded?: boolean; nositelinkssearchbox?: boolean; unavailable_after?: string; 'max-video-preview'?: number; 'max-image-preview'?: 'none' | 'standard' | 'large'; 'max-snippet'?: number };
+type Icon = Url | { url: Url; rel?: string; sizes?: string; type?: string; media?: string; color?: string; fetchPriority?: 'high' | 'low' | 'auto' };
+type Social = { title?: Title; description?: string; images?: OneOrMany<Image> };
+type OpenGraph = Social & {
+  type?: 'website' | 'article' | 'book' | 'profile' | 'music.song' | 'music.album' | 'music.playlist' | 'music.radio_station' | 'video.movie' | 'video.episode' | 'video.tv_show' | 'video.other';
+  url?: Url; siteName?: string; locale?: string; countryName?: string; determiner?: string; ttl?: number;
+  emails?: OneOrMany<string>; phoneNumbers?: OneOrMany<string>; faxNumbers?: OneOrMany<string>; alternateLocale?: OneOrMany<string>;
+  audio?: OneOrMany<Url | { url: Url; secureUrl?: Url; type?: string }>; videos?: OneOrMany<Image>;
+  publishedTime?: string; modifiedTime?: string; expirationTime?: string; authors?: OneOrMany<string>; section?: string; tags?: OneOrMany<string>;
+  isbn?: string; releaseDate?: string; firstName?: string; lastName?: string; username?: string; gender?: string;
+  duration?: number; albums?: OneOrMany<Url | { url: Url; disc?: number; track?: number }>; songs?: OneOrMany<Url | { url: Url; disc?: number; track?: number }>;
+  musicians?: OneOrMany<string>; creators?: OneOrMany<string>; actors?: OneOrMany<Url | { url: Url; role?: string }>; directors?: OneOrMany<string>; writers?: OneOrMany<string>; series?: Url;
+};
+type Twitter = Social & {
+  card?: 'summary' | 'summary_large_image' | 'player' | 'app'; site?: string; siteId?: string; creator?: string; creatorId?: string;
+  players?: OneOrMany<{ playerUrl: string; streamUrl: string; width: number; height: number }>;
+  app?: { name?: string; id: { iphone?: string | number; ipad?: string | number; googleplay?: string }; url?: { iphone?: string; ipad?: string; googleplay?: string } };
+};
+export interface Viewport {
+  width?: string | number; height?: string | number; initialScale?: number; minimumScale?: number; maximumScale?: number; userScalable?: boolean;
+  viewportFit?: 'auto' | 'cover' | 'contain'; interactiveWidget?: 'resizes-visual' | 'resizes-content' | 'overlays-content';
+  themeColor?: string | Array<{ color: string; media?: string }> | null;
+  colorScheme?: string | null;
+}
+export interface Metadata {
+  metadataBase?: URL | null; title?: Title | null; description?: string | null; applicationName?: string | null; generator?: string | null;
+  referrer?: string | null; keywords?: OneOrMany<string> | null; authors?: OneOrMany<{ name?: string; url?: Url }> | null;
+  creator?: string | null; publisher?: string | null; category?: string | null; abstract?: string | null; classification?: string | null;
+  manifest?: Url | null; robots?: string | (Robots & { googleBot?: string | Robots }) | null;
+  alternates?: { canonical?: Url | UrlDescriptor | null; languages?: Record<string, Url | UrlDescriptor[]> | null; media?: Record<string, Url | UrlDescriptor[]> | null; types?: Record<string, Url | UrlDescriptor[]> | null } | null;
+  icons?: OneOrMany<Icon> | { icon?: OneOrMany<Icon>; shortcut?: OneOrMany<Icon>; apple?: OneOrMany<Icon>; other?: OneOrMany<Icon> } | null;
+  openGraph?: OpenGraph | null; twitter?: Twitter | null;
+  verification?: { google?: OneOrMany<string | number>; yahoo?: OneOrMany<string | number>; yandex?: OneOrMany<string | number>; me?: OneOrMany<string | number>; other?: Record<string, OneOrMany<string | number>> };
+  appleWebApp?: boolean | { capable?: boolean; title?: string; statusBarStyle?: 'default' | 'black' | 'black-translucent'; startupImage?: OneOrMany<Url | { url: Url; media?: string }> } | null;
+  formatDetection?: { telephone?: boolean; date?: boolean; address?: boolean; email?: boolean; url?: boolean } | null;
+  itunes?: { appId: string; appArgument?: string } | null;
+  facebook?: { appId?: string; admins?: OneOrMany<string> } | null; pinterest?: { richPin: boolean };
+  archives?: OneOrMany<string> | null; assets?: OneOrMany<string> | null; bookmarks?: OneOrMany<string> | null; pagination?: { previous?: Url | null; next?: Url | null };
+  appLinks?: {
+    ios?: OneOrMany<{ url: Url; app_store_id?: string | number; app_name?: string }>; iphone?: OneOrMany<{ url: Url; app_store_id?: string | number; app_name?: string }>; ipad?: OneOrMany<{ url: Url; app_store_id?: string | number; app_name?: string }>;
+    android?: OneOrMany<{ package: string; url?: Url; class?: string; app_name?: string }>;
+    windows_phone?: OneOrMany<{ url: Url; app_id?: string; app_name?: string }>; windows?: OneOrMany<{ url: Url; app_id?: string; app_name?: string }>; windows_universal?: OneOrMany<{ url: Url; app_id?: string; app_name?: string }>;
+    web?: OneOrMany<{ url: Url; should_fallback?: boolean }>;
+  } | null;
+  other?: Record<string, OneOrMany<string | number>>;
+}
+export type ResolvingMetadata = Promise<Omit<Metadata, 'title' | 'openGraph' | 'twitter' | 'metadataBase'> & {
+  title: { absolute: string; template: string | null } | null;
+  metadataBase?: string | null;
+  openGraph?: Omit<OpenGraph, 'images' | 'title'> & { images?: Exclude<Image, Url>[]; title?: { absolute: string; template: string | null } } | null;
+  twitter?: Omit<Twitter, 'images' | 'title'> & { images?: Exclude<Image, Url>[]; title?: { absolute: string; template: string | null } } | null;
+}>;
+export type ResolvingViewport = Promise<Viewport>;
+export namespace MetadataRoute {
+  type Robots = {
+    rules: OneOrMany<{ userAgent?: OneOrMany<string>; allow?: OneOrMany<string>; disallow?: OneOrMany<string>; crawlDelay?: number; other?: Record<string, OneOrMany<string> | null> }>;
+    sitemap?: OneOrMany<string>; host?: string;
+  };
+  type Sitemap = Array<{
+    url: string; lastModified?: string | Date; changeFrequency?: 'always' | 'hourly' | 'daily' | 'weekly' | 'monthly' | 'yearly' | 'never'; priority?: number;
+    alternates?: { languages?: Record<string, string> }; images?: string[];
+    videos?: Array<{ title: string; thumbnail_loc: string; description: string; content_loc?: string; player_loc?: string; duration?: number; view_count?: number; tag?: string; rating?: number; expiration_date?: string; publication_date?: string; family_friendly?: 'yes' | 'no'; requires_subscription?: 'yes' | 'no'; live?: 'yes' | 'no'; restriction?: { relationship: 'allow' | 'deny'; content: string }; platform?: { relationship: 'allow' | 'deny'; content: string }; uploader?: { content: string; info?: string } }>;
+  }>;
+  interface Manifest {
+    name?: string; short_name?: string; description?: string; id?: string; start_url?: string; scope?: string; lang?: string; dir?: 'auto' | 'ltr' | 'rtl';
+    display?: 'fullscreen' | 'standalone' | 'minimal-ui' | 'browser'; display_override?: string[]; orientation?: string; background_color?: string; theme_color?: string; categories?: string[];
+    icons?: Array<{ src: string; sizes?: string; type?: string; purpose?: string }>; screenshots?: Array<{ src: string; sizes?: string; type?: string; form_factor?: string; label?: string }>;
+    shortcuts?: Array<{ name: string; short_name?: string; description?: string; url: string; icons?: Manifest['icons'] }>;
+    related_applications?: Array<{ platform: string; url?: string; id?: string }>; prefer_related_applications?: boolean;
+    [extension: string]: unknown;
+  }
+}

package/compat/navigation-controls.cjs

@@ -0,0 +1,27 @@
+'use strict';
+
+const RedirectType = Object.freeze({ push: 'push', replace: 'replace' });
+function redirectError(url, type, status) {
+  if (typeof url !== 'string' || /[\r\n]/.test(url)) throw new TypeError('Invalid redirect destination');
+  if (type !== 'push' && type !== 'replace') throw new TypeError('Invalid redirect type');
+  const error = new Error('NEXT_REDIRECT');
+  error.digest = `NEXT_REDIRECT;${type};${url};${status};`;
+  return error;
+}
+function redirect(url, type = RedirectType.replace) { throw redirectError(url, type, 307); }
+function permanentRedirect(url, type = RedirectType.replace) { throw redirectError(url, type, 308); }
+function notFound() {
+  const error = new Error('NEXT_HTTP_ERROR_FALLBACK;404');
+  error.digest = 'NEXT_HTTP_ERROR_FALLBACK;404';
+  throw error;
+}
+function unstable_rethrow(error) {
+  if (typeof error?.digest === 'string' &&
+      (error.digest.startsWith('NEXT_REDIRECT;') || error.digest.startsWith('NEXT_HTTP_ERROR_FALLBACK;'))) throw error;
+}
+
+module.exports.redirect = redirect;
+module.exports.permanentRedirect = permanentRedirect;
+module.exports.notFound = notFound;
+module.exports.RedirectType = RedirectType;
+module.exports.unstable_rethrow = unstable_rethrow;