@thomas.f/prnext 0.1.17-alpha → 0.1.18-alpha

package/compat/flight-delta.cjs

@@ -0,0 +1,150 @@
+'use strict';
+
+const WINDOW = 32, MAX_VALUE = 2 * 1024 * 1024, MAX_RESPONSE = 16 * 1024 * 1024;
+const TYPE = 'application/x-prnext-flight-delta';
+const MAGIC = new Uint8Array([80,82,68,49]);
+const BLOCK_BYTES = 32 * 1024, MAX_COMMANDS_PER_CHUNK = 256, MAX_COMMANDS = 2048;
+let POWER = 1; for(let n=1;n<WINDOW;n++) POWER = Math.imul(POWER,31) >>> 0;
+function hash(bytes,offset) { let result=0; for(let n=0;n<WINDOW;n++) result=(Math.imul(result,31)+bytes[offset+n])>>>0; return result; }
+function createIndex(base) {
+  const index=new Map();
+  for(let offset=0;offset+WINDOW<=base.length;offset+=WINDOW) {
+    const key=hash(base,offset), candidates=index.get(key)||[];
+    if(candidates.length<4)candidates.push(offset); index.set(key,candidates);
+  }
+  return index;
+}
+function frame(tag,a,b) { const value=new Uint8Array(tag===1?9:5), view=new DataView(value.buffer); value[0]=tag;view.setUint32(1,a);if(tag===1)view.setUint32(5,b);return value; }
+function encodeChunk(bytes,base,index) {
+  const output=[];let cursor=0,literal=0,key=bytes.length>=WINDOW?hash(bytes,0):0,work=0,commands=0;
+  const budget=bytes.length*8+32768;
+  const emit=end=>{if(end>literal){commands++;output.push(frame(0,end-literal),bytes.subarray(literal,end));}};
+  while(cursor+WINDOW<=bytes.length) {
+    if(work>budget||commands>=MAX_COMMANDS_PER_CHUNK)return null;
+    let match=-1;
+    for(const offset of index.get(key)||[]) {let n=0;while(n<WINDOW&&bytes[cursor+n]===base[offset+n]){n++;work++;}if(n===WINDOW){match=offset;break;}}
+    if(match!==-1) {
+      emit(cursor);let length=WINDOW;
+      while(cursor+length<bytes.length&&match+length<base.length&&bytes[cursor+length]===base[match+length]){length++;work++;}
+      commands++;output.push(frame(1,match,length));cursor+=length;literal=cursor;
+      if(cursor+WINDOW<=bytes.length)key=hash(bytes,cursor);
+    } else {
+      key=(Math.imul((key-Math.imul(bytes[cursor],POWER))>>>0,31)+bytes[cursor+WINDOW])>>>0;cursor++;
+    }
+  }
+  emit(bytes.length);if(commands>MAX_COMMANDS_PER_CHUNK)return null;output.commands=commands;return output;
+}
+function join(parts,size) { const result=new Uint8Array(size);let offset=0;for(const part of parts){result.set(part,offset);offset+=part.length;}return result; }
+// Commands are a wire format, not scheduling units. Thousands of tiny writes
+// defeat gzip and multiply worker IPC/socket work even when the raw delta saves
+// bytes. Bound each outgoing block without reading ahead into a delayed chunk.
+function blocks(parts) {
+  const output=[];let pending=[],size=0;
+  const flush=()=>{if(size)output.push(pending.length===1?pending[0]:join(pending,size));pending=[];size=0;};
+  for(const part of parts)for(let offset=0;offset<part.length;){const n=Math.min(BLOCK_BYTES-size,part.length-offset);pending.push(part.subarray(offset,offset+n));size+=n;offset+=n;if(size===BLOCK_BYTES)flush();}
+  flush();return output;
+}
+function collectStream(source,{onComplete,onCancel,onFinally,capture=true}={}) {
+  const reader=source.getReader(), parts=[];let size=0,complete=false,finished=false;
+  const finish=()=>{if(!finished){finished=true;onFinally?.();}};
+  return new ReadableStream({
+    async pull(controller) {try{const next=await reader.read();if(next.done){complete=true;if(capture&&size<=MAX_VALUE)onComplete?.(join(parts,size));parts.length=0;finish();controller.close();return;}if(!(next.value instanceof Uint8Array))throw new Error('Invalid Flight bytes');size+=next.value.length;if(size>MAX_RESPONSE)throw new Error('Flight exceeds transport budget');if(capture&&size<=MAX_VALUE)parts.push(next.value.slice());else parts.length=0;controller.enqueue(next.value);}catch(error){parts.length=0;finish();controller.error(error);await reader.cancel(error).catch(()=>{});}},
+    async cancel(reason){parts.length=0;finish();if(!complete)onCancel?.();await reader.cancel(reason);},
+  },{highWaterMark:0});
+}
+async function deltaStream(source,base,{assess}={}) {
+  const reader=source.getReader(), first=await reader.read();
+  if(first.done)return {delta:false,body:new ReadableStream({start(c){c.close();}})};
+  let index=base instanceof Uint8Array&&base.length<=MAX_VALUE?createIndex(base):null;
+  const profitable=(raw,frames,initial)=>frames&&frames.reduce((n,b)=>n+b.length,0)+(initial?5:1)<raw.length*0.9&&(!assess||assess(raw,join(initial?[MAGIC,...frames,new Uint8Array([2])]:frames,frames.reduce((n,b)=>n+b.length,0)+(initial?5:0)))===true);
+  const firstFrames=index&&first.value.length>=WINDOW?encodeChunk(first.value,base,index):null;
+  let useDelta;
+  try{useDelta=!!profitable(first.value,firstFrames,true);}catch(error){await reader.cancel(error).catch(()=>{});throw error;}
+  let pending=useDelta?blocks([MAGIC,...firstFrames]):[first.value], pendingAt=0,ended=false,tail=false,commands=firstFrames?.commands||0;
+  if(!useDelta){base=undefined;index=undefined;}
+  return {delta:!!useDelta,body:new ReadableStream({
+    async pull(controller){try{
+      if(pendingAt===pending.length&&!ended){pending=[];pendingAt=0;const next=await reader.read();
+        if(next.done){ended=true;if(useDelta&&!tail)pending=[new Uint8Array([2])];}
+        else if(useDelta&&!tail){const encoded=encodeChunk(next.value,base,index);commands+=encoded?.commands||0;
+          if(commands>MAX_COMMANDS||!profitable(next.value,encoded,false)){tail=true;index=undefined;base=undefined;pending=blocks([new Uint8Array([3]),next.value]);}
+          else pending=blocks(encoded);
+        }else pending=[next.value];
+      }
+      if(pendingAt<pending.length)controller.enqueue(pending[pendingAt++]);else if(ended)controller.close();
+    }catch(error){pending=[];base=undefined;index=undefined;controller.error(error);await reader.cancel(error).catch(()=>{});}},
+    cancel(reason){pending=[];base=undefined;index=undefined;ended=true;return reader.cancel(reason);},
+  },{highWaterMark:0})};
+}
+function decodeStream(source,base) {
+  const reader=source.getReader();let chunks=[],head=0,available=0,offset=0,total=0,wireTotal=0,started=false,ended=false,tail=false,commands=0;
+  function consume(size){
+    const first=chunks[head];
+    if(first&&first.length-offset>=size){const result=first.subarray(offset,offset+size);offset+=size;available-=size;if(offset===first.length){head++;offset=0;}return result;}
+    const result=new Uint8Array(size);let written=0;
+    while(written<size){const value=chunks[head],count=Math.min(size-written,value.length-offset);result.set(value.subarray(offset,offset+count),written);written+=count;offset+=count;available-=count;if(offset===value.length){head++;offset=0;}}
+    return result;
+  }
+  async function take(size) {
+    if(size>MAX_RESPONSE)throw new Error('Invalid Flight delta frame size');
+    while(available<size){const next=await reader.read();if(next.done)throw new Error('Truncated Flight delta');if(!(next.value instanceof Uint8Array))throw new Error('Invalid Flight delta bytes');wireTotal+=next.value.length;if(wireTotal>MAX_RESPONSE+1024*1024)throw new Error('Flight delta wire budget exceeded');if(next.value.length){if(head){chunks=chunks.slice(head);head=0;}chunks.push(next.value);available+=next.value.length;}}
+    return consume(size);
+  }
+  function peek(at){let index=head,position=offset+at;while(index<chunks.length){if(position<chunks[index].length)return chunks[index][position];position-=chunks[index++].length;}}
+  function bufferedCommand(){
+    if(!available)return false;
+    const tag=peek(0);if(tag!==0&&tag!==1)return true;
+    if(available<(tag===1?9:5))return false;
+    const length=tag===1?0:((peek(1)*0x1000000)+(peek(2)<<16)+(peek(3)<<8)+peek(4));
+    return length>MAX_RESPONSE||available>=5+length;
+  }
+  async function pullTail(controller){
+    const next=available?{value:await take(available),done:false}:await reader.read();
+    if(next.done){ended=true;controller.close();return;}
+    if(!(next.value instanceof Uint8Array))throw new Error('Invalid Flight delta bytes');
+    total+=next.value.length;if(total>MAX_RESPONSE)throw new Error('Decoded Flight exceeds transport budget');controller.enqueue(next.value);
+  }
+  return new ReadableStream({
+    async pull(controller){try{
+      if(tail)return await pullTail(controller);
+      if(!started){const magic=await take(4);if(!magic.every((value,n)=>value===MAGIC[n]))throw new Error('Unsupported Flight delta version');started=true;}
+      if(ended)return controller.close();
+      const output=[];let size=0;
+      do {
+      // Publish decoded data before waiting for another source chunk or the
+      // final EOF. This preserves Suspense flushes and downstream backpressure.
+      if(output.length&&(!bufferedCommand()||peek(0)===2||peek(0)===3))break;
+      if(++commands>65536)throw new Error('Flight delta command budget exceeded');
+      const [tag]=await take(1);let value;
+      if(tag===3){tail=true;return await pullTail(controller);}
+      if(tag===2){ended=true;if(available)throw new Error('Trailing Flight delta data');const rest=await reader.read();if(!rest.done)throw new Error('Trailing Flight delta data');controller.close();return;}
+      if(tag===0){const header=await take(4),length=new DataView(header.buffer,header.byteOffset,header.byteLength).getUint32(0);if(!length)throw new Error('Empty Flight delta literal');value=await take(length);}
+      else if(tag===1){const header=await take(8),view=new DataView(header.buffer,header.byteOffset,header.byteLength),start=view.getUint32(0),length=view.getUint32(4);if(!length||start+length>base.length)throw new Error('Invalid Flight delta reference');value=base.subarray(start,start+length);}
+      else throw new Error('Invalid Flight delta command');
+      total+=value.length;if(total>MAX_RESPONSE)throw new Error('Decoded Flight exceeds transport budget');output.push(value);size+=value.length;
+      }while(size<BLOCK_BYTES);
+      controller.enqueue(output.length===1?output[0]:join(output,size));
+    }catch(error){chunks=[];controller.error(error);await reader.cancel(error).catch(()=>{});}},
+    cancel:reason=>{chunks=[];return reader.cancel(reason);},
+  },{highWaterMark:0});
+}
+function createFlightTransport() {
+  let current,serial=0;
+  return {
+    snapshot(){return current;},
+    async response(response,base) {
+      const version=++serial;
+      const token=response.headers.get('x-prnext-flight-token'), headers=new Headers(response.headers);
+      let source=response.body;
+      if(!source)return response;
+      if(headers.get('content-type')?.startsWith(TYPE)) {
+        if(!base||headers.get('x-prnext-flight-base')!==base.token){await source.cancel();throw new Error('Missing Flight delta base');}
+        source=decodeStream(source,base.bytes);
+      }
+      headers.set('content-type','text/x-component; charset=utf-8');headers.delete('content-length');headers.delete('content-encoding');
+      return new Response(collectStream(source,{capture:!!token&&/^[a-f0-9]{48}$/.test(token),onComplete:bytes=>{if(version===serial&&token&&/^[a-f0-9]{48}$/.test(token))current={token,bytes};}}),{status:response.status,statusText:response.statusText,headers});
+    },
+    clear(){serial++;current=undefined;},
+  };
+}
+module.exports={TYPE,MAX_VALUE,createIndex,encodeChunk,deltaStream,decodeStream,collectStream,createFlightTransport};

package/compat/headers.cjs

@@ -63,12 +63,14 @@ function runRequestContext(input, callback) {
   return requestStorage.run(context, callback);
 }
 
+function assertAfterRequestData(name) { const context = currentRequest(); if (context.phase === 'after' && context.afterRestricted) throw new Error(`${name}() cannot be called inside after() registered by a Server Component; read it before registering the callback`); }
 function assertUncached(name) {
   if (inCacheScope()) throw new Error(`${name}() cannot be accessed inside unstable_cache; read it outside and pass the required values as arguments`);
 }
-async function headers() { if (currentRequest().instantValidation && currentRequest().instantSample) { assertUncached('headers'); return sampleMethods(currentRequest(), 'headers', currentRequest().headers); } if (currentCacheScope()?.kind !== 'private') assertUncached('headers'); dynamicUsage('headers()'); return currentRequest().headers; }
-async function cookies() { if (currentRequest().instantValidation && currentRequest().instantSample) { assertUncached('cookies'); return sampleMethods(currentRequest(), 'cookies', currentRequest().cookies); } if (currentCacheScope()?.kind !== 'private') assertUncached('cookies'); dynamicUsage('cookies()'); return currentRequest().cookies; }
+async function headers() { assertAfterRequestData('headers'); if (currentRequest().instantValidation && currentRequest().instantSample) { assertUncached('headers'); return sampleMethods(currentRequest(), 'headers', currentRequest().headers); } if (currentCacheScope()?.kind !== 'private') assertUncached('headers'); dynamicUsage('headers()'); return currentRequest().headers; }
+async function cookies() { assertAfterRequestData('cookies'); if (currentRequest().instantValidation && currentRequest().instantSample) { assertUncached('cookies'); return sampleMethods(currentRequest(), 'cookies', currentRequest().cookies); } if (currentCacheScope()?.kind !== 'private') assertUncached('cookies'); dynamicUsage('cookies()'); return currentRequest().cookies; }
 async function draftMode() {
+  assertAfterRequestData('draftMode');
   const context = currentRequest();
   if (!context.draftProvider) context.draftProvider = {
     get isEnabled() { return context.draftMode; },

package/compat/incremental-cache.cjs

@@ -78,6 +78,7 @@ async function invalidate(context, operation) {
   await invoke(handler, 'revalidateTag', [[...new Set(tags)], durations], context);
 }
 function fresh(entry, revalidate) {
+  if (entry?.isStale === true) return false;
   const timestamp = entry?.lastModified;
   if (!Number.isFinite(timestamp) || timestamp < 0 || timestamp > Date.now() + 60_000) return false;
   const stored = entry.value?.revalidate;
@@ -124,14 +125,18 @@ async function cachedIncrementalValue(key, producer, options) {
   let complete;
   const owner = { revision, done: new Promise(resolve => { complete = resolve; }) };
   if (ownersCount < 64) { record.owners.set(key, owner); ownersCount++; }
-  let lease;
+  let lease, sharedLease;
   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();
+    try {
+      if (sharedLease && handler.prnextLeaseVersion === 1 && typeof handler.release === 'function') await invoke(handler, 'release', [key, sharedLease], { ...context, signal: undefined });
+    } finally {
+      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;
@@ -140,7 +145,7 @@ async function cachedIncrementalValue(key, producer, options) {
     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 } };
+    const setContext = { ...getContext, tags: [...new Set([...tags, ...implicit])], cacheControl: { revalidate }, prnextLease: sharedLease };
     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
@@ -152,7 +157,15 @@ async function cachedIncrementalValue(key, producer, options) {
   const work = (async () => {
     try {
       lease = await cache.acquireExternalCacheLease(key, signal);
-      if (lease) {
+      if (handler.prnextLeaseVersion === 1 && typeof handler.acquire === 'function') {
+        const until = Date.now() + 25000;
+        for (;;) {
+          signal?.throwIfAborted();
+          try { sharedLease = await invoke(handler, 'acquire', [key, { signal }], context); break; }
+          catch (error) { if (error.code !== 'PRNEXT_REDIS_BUSY' || Date.now() >= until) throw error; }
+        }
+      }
+      if (lease || sharedLease) {
         // Even an immediately granted lease may follow a producer that finished
         // between our first backend read and this native admission.
         let shared;

package/compat/index.d.ts

@@ -13,6 +13,13 @@ export interface InstantSample {
 }
 export type InstantConfig = boolean | { level?: 'warning' | 'experimental-error'; unstable_samples?: InstantSample[]; unstable_disableValidation?: true; unstable_disableDevValidation?: true; unstable_disableBuildValidation?: true };
 
+export interface ReactCompilerOptions {
+  compilationMode?: 'infer' | 'annotation';
+  panicThreshold?: 'none' | 'critical_errors' | 'all_errors';
+  /** PRNext requires matching React 19 peers. */
+  target?: '19';
+}
+
 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};
@@ -117,9 +124,17 @@ export interface NextConfig {
   /** PRNext only. CLI > environment > build configuration > profile.
    * 0 disables the corresponding retirement; keepWarm retains one lane per used host.
    */
+  /** Soft RSS retirement after three one-second samples; active work drains. */
+  workerMemory?: false | { maxRssMb: number };
   workerRetirement?: { idleSeconds?: number; laneIdleSeconds?: number; keepWarm?: boolean };
   /** Import selected Node routes on startup; top-level module code executes. RSS is a soft import budget. */
   workerPreload?: false | { routes: string[]; maxRssMb?: number; timeoutMs?: number };
+  /** Keep bounded previous public hashed assets. false disables carry-over. Defaults: one hour, two generations, 64 MiB. */
+  deploymentRetention?: false | {maxAge?: number; maxGenerations?: number; maxBytes?: number};
+  /** PRNext production prerender processes; maxMemoryMb bounds their combined observed memory. */
+  prerender?: {workers?: number; maxMemoryMb?: number};
+  /** Explicit App route patterns that must produce complete static HTML without browser JavaScript. */
+  htmlOnly?: string[];
   /** Bounded active development routes; default retains five requested routes. */
   onDemandEntries?: { maxInactiveAge?: number; pagesBufferLength?: number };
   /** PRNext development menu; bottom-left by default. false hides it without disabling errors or Fast Refresh. */
@@ -130,8 +145,8 @@ export interface NextConfig {
   images?: import('./image.cjs').ImageConfig;
   pageExtensions?: string[];
   reactStrictMode?: boolean;
-  /** Enabled React Compiler transforms are not implemented. */
-  reactCompiler?: false;
+  /** Opt in to the bundled official React Compiler for application components. Disabled by default. */
+  reactCompiler?: boolean | ReactCompilerOptions;
   /** Generate route completions and validate Link/router destinations. */
   typedRoutes?: boolean;
   /** Native CSS for default styles; custom PostCSS pipelines remain authoritative. */
@@ -139,6 +154,9 @@ export interface NextConfig {
   /** Production checks use the project's installed TypeScript without emitting files. */
   typescript?: { ignoreBuildErrors?: boolean; tsconfigPath?: string; devChecks?: boolean };
   cacheComponents?: boolean;
+  partialPrefetching?: boolean;
+  /** App Router inactive layout branches. Defaults to 4 entries for 120 seconds. */
+  navigationCache?: false | {maxEntries?: number; ttlMs?: number; authCookies?: readonly string[]};
   cacheLife?: Record<string, import('./cache.cjs').CacheLife>;
   transpilePackages?: string[];
   serverExternalPackages?: string[];
@@ -196,7 +214,45 @@ export interface StaticBuildOptions {
   distDir?: string;
   dev?: false;
 }
-export interface BuildResult { buildId: string; outputDirectory: string; }
+export interface ReactCompilerReport {
+  version: 1;
+  compilerVersion: string | null;
+  enabled: boolean;
+  buildId: string | null;
+  mode: 'development' | 'production';
+  /** Incremental graphs can reuse inputs without observing their transforms. */
+  scope: 'observed-transforms';
+  options: boolean | ReactCompilerOptions | null;
+  truncated: boolean;
+  summary: {files: number; functions: number; optimized: number; skipped: number; errors: number; diagnostics: number; mixed: number; transforms: number; cacheReuses: number};
+  files: Array<{
+    file: string; transforms: number; cacheReuses: number; targets: string[]; notes: string[];
+    functions: Array<{
+      name: string | null;
+      start: {line: number; column: number} | null;
+      end: {line: number; column: number} | null;
+      status: 'optimized' | 'skipped' | 'error' | 'diagnostic' | 'mixed';
+      targets: string[];
+      events: Array<{
+        kind: 'CompileSuccess' | 'CompileSkip' | 'CompileError' | 'CompileDiagnostic' | 'PipelineError';
+        status: 'optimized' | 'skipped' | 'error' | 'diagnostic' | 'mixed';
+        reason: string | null; category: string | null; targets: string[]; policy?: boolean;
+        memoSlots?: number; memoBlocks?: number; memoValues?: number;
+      }>;
+    }>;
+  }>;
+  graphs: Array<{target: string; metadataAvailable: boolean; projectJavaScriptInputs: number; observedFiles: number; unobservedInputs: number}>;
+}
+export interface CompilationCacheReport {
+  version: 1;
+  scope: 'eligible-production-compilation-graphs';
+  hits: number;
+  misses: number;
+  bypasses: number;
+  reusedBytes: number;
+  kinds: Array<{kind: string; hits: number; misses: number; bypasses: number; writes: number; reusedBytes: number; reasons: Record<string, number>}>;
+}
+export interface BuildResult { buildId: string; outputDirectory: string; reactCompilerReport?: ReactCompilerReport; compilationCache?: CompilationCacheReport; }
 export interface ProductionBuilder {
   build(options?: {envMode?: 'production' | 'test'}): Promise<BuildResult>;
   stats(): {contexts: number; created: number; reused: number};
@@ -212,3 +268,12 @@ export function buildStatic(projectRoot: string, options?: StaticBuildOptions):
 export function readBuildOutput(buildDirectory: string): Promise<BuildOutput>;
 export function validateBuildOutput(value: unknown): BuildOutput;
 export type { DocumentContext, DocumentInitialProps, DocumentProps } from './document.cjs';
+
+/** Server instrumentation hooks, compatible with Next.js instrumentation files. */
+export namespace Instrumentation {
+  export type onRequestError = (error: unknown, request: Readonly<{path: string; method: string; headers: Record<string,string|string[]>}>, context: {
+    routerKind: 'App Router' | 'Pages Router'; routePath: string; routeType: 'render' | 'route' | 'action' | 'proxy';
+    renderSource: 'react-server-components' | 'react-server-components-payload' | 'server-rendering';
+    revalidateReason: 'on-demand' | 'stale' | undefined; renderType: 'dynamic' | 'dynamic-resume';
+  }) => void | Promise<void>;
+}

package/compat/link.cjs

@@ -7,7 +7,7 @@ const { addBasePath, hasBasePath, normalizeTrailingSlash } = require('./paths.cj
 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) {
+  locale, legacyBehavior, passHref, onClick, onNavigate, onMouseEnter, onTouchStart, onFocus, ...props }, ref) {
   const app = React.useContext(AppRouterContext);
   const pages = React.useContext(RouterContext);
   const anchorRef = React.useRef(null);
@@ -19,14 +19,15 @@ const Link = React.forwardRef(function Link({ href, as, children, replace, scrol
     : 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]);
+  const requestPrefetch = React.useCallback((priority = 'intent') => {
+    if (prefetch === false || process.env.NODE_ENV !== 'production') return;
+    if (app?.router.partialPrefetch) app.router.prefetch(target, { priority, full: prefetch === true });
+    if (!app && pages) void pages.prefetch(source, as ? target : undefined, { locale, priority }).catch(() => {});
+  }, [app, pages, source, target, as, locale, 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(); }
+      if (entries.some(entry => entry.isIntersecting)) { observer.disconnect(); requestPrefetch('viewport'); }
     }, { rootMargin: '200px' });
     observer.observe(anchorRef.current);
     return () => observer.disconnect();
@@ -53,16 +54,18 @@ const Link = React.forwardRef(function Link({ href, as, children, replace, scrol
       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(); }
+  function hover(event) { onMouseEnter?.(event); if (!event.defaultPrevented) requestPrefetch(); }
+  function touch(event) { onTouchStart?.(event); if (!event.defaultPrevented) requestPrefetch(); }
+  function focus(event) { onFocus?.(event); if (!event.defaultPrevented) 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); },
+      onFocus(event) { child.props.onFocus?.(event); focus(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);
+  return React.createElement('a', { ...props, href: publicTarget, ref: setRef, onClick: click, onMouseEnter: hover, onTouchStart: touch, onFocus: focus }, children);
 });
 module.exports = Link;
 module.exports.default = Link;

package/compat/navigation-authorization.cjs

@@ -0,0 +1,9 @@
+'use strict';
+const { createHmac } = require('node:crypto');
+function navigationAuthorization(context, secret, cookieNames) {
+  if (!secret || context?.staticState) return undefined;
+  const names = cookieNames === undefined ? null : new Set(cookieNames);
+  const cookies = context.cookies.getAll().filter(cookie => !names || names.has(cookie.name)).map(({ name, value }) => [name, value]).sort((a, b) => a[0].localeCompare(b[0]));
+  return createHmac('sha256', secret).update(JSON.stringify([cookies, context.headers.get('authorization') || ''])).digest('hex');
+}
+module.exports = { navigationAuthorization };

package/compat/navigation-stages.cjs

@@ -0,0 +1,19 @@
+'use strict';
+const { optionalRequestContext, inCacheScope } = require('./data-cache.cjs');
+
+function postponeStage(name) {
+  throw Object.assign(new Error(`Deferred until ${name}.`), { code: 'PRNEXT_PPR_DYNAMIC', digest: 'PRNEXT_PPR_DYNAMIC' });
+}
+function stage(name) {
+  const context = optionalRequestContext();
+  if (!context?.cacheComponents) throw new Error(`${name}() requires cacheComponents: true.`);
+  if (inCacheScope()) throw new Error(`${name}() cannot run inside a cached function. Call it before invoking the cached function.`);
+  // Static prerenders deliberately continue through both gates. Cacheable work
+  // remains prerenderable and is not made request-dependent by either API.
+  if (context.staticState) return;
+  if (context.navigationStage === 'shell' && (name === 'navigation' || context.partialPrefetching)) postponeStage(name);
+  if (context.navigationStage === 'prefetch' && name === 'navigation') postponeStage(name);
+}
+async function navigation() { stage('navigation'); }
+async function prefetch() { stage('prefetch'); }
+module.exports = { navigation, prefetch, postponeStage };

package/compat/offline-store.cjs

@@ -0,0 +1,11 @@
+'use strict';
+const waiting=new Set(),listeners=new Set();
+const changed=()=>{for(const listener of listeners)listener();};
+const snapshot=()=>waiting.size>0||globalThis.navigator?.onLine===false;
+function subscribe(listener){
+  if(!listeners.size){globalThis.window?.addEventListener('online',changed);globalThis.window?.addEventListener('offline',changed);}
+  listeners.add(listener);
+  return()=>{listeners.delete(listener);if(!listeners.size){globalThis.window?.removeEventListener('online',changed);globalThis.window?.removeEventListener('offline',changed);}};
+}
+function beginWait(){const id={};waiting.add(id);changed();let ended=false;return()=>{if(ended)return;ended=true;waiting.delete(id);changed();};}
+module.exports={snapshot,subscribe,beginWait};

package/compat/offline.cjs

@@ -0,0 +1,5 @@
+'use client';
+'use strict';
+const React=require('react'),store=require('./offline-store.cjs');
+function useOffline(){return React.useSyncExternalStore(store.subscribe,store.snapshot,()=>false);}
+module.exports={useOffline};

package/compat/offline.d.cts

@@ -0,0 +1,2 @@
+/** True when the browser is offline or a navigation is waiting for connectivity. */
+export declare function useOffline(): boolean;