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

package/compat/cookies.cjs

@@ -1,13 +1,13 @@
 'use strict';
 
-function parseCookieHeader(value = '') {
+function parseCookieHeader(value = '', { ignoreMalformed = false } = {}) {
   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. */ }
+    try { value = decodeURIComponent(value); } catch { if (ignoreMalformed) continue; }
     values.set(name, { name, value });
   }
   return values;
@@ -50,7 +50,7 @@ function serializeCookie(cookie) {
 
 function parseResponseCookie(header) {
   const [pair, ...attributes] = header.split(';');
-  const cookie = parseCookieHeader(pair).values().next().value;
+  const cookie = parseCookieHeader(pair, { ignoreMalformed: true }).values().next().value;
   if (!cookie) return;
   for (const attribute of attributes) {
     const separator = attribute.indexOf('=');
@@ -71,7 +71,7 @@ function parseResponseCookie(header) {
 
 class CookieStore {
   constructor(header, { mutable = false, onChange } = {}) {
-    this._cookies = parseCookieHeader(header);
+    this._cookies = parseCookieHeader(header, { ignoreMalformed: true });
     this._mutable = mutable;
     this._onChange = onChange;
   }
@@ -99,6 +99,22 @@ class CookieStore {
   *[Symbol.iterator]() { for (const [name, cookie] of this._cookies) yield [name, { ...cookie }]; }
 }
 
+class RequestCookieStore extends CookieStore {
+  constructor(headers) {
+    super(headers.get('cookie') || '', { mutable: true, onChange: () => headers.set('cookie', this.toString()) });
+  }
+  set(name, value) {
+    const cookie = typeof name === 'object' ? { name: name.name, value: name.value } : { name, value };
+    return super.set(cookie);
+  }
+  delete(names) {
+    const result = Array.isArray(names) ? names.map(name => this._cookies.delete(name)) : this._cookies.delete(names);
+    this._onChange?.();
+    return result;
+  }
+  clear() { this.delete([...this._cookies.keys()]); return this; }
+}
+
 class ResponseCookieStore extends CookieStore {
   constructor(headers) {
     super('', { mutable: true });
@@ -126,4 +142,4 @@ class ResponseCookieStore extends CookieStore {
   toString() { return [...this._cookies.values()].map(serializeCookie).join('; '); }
 }
 
-module.exports = { CookieStore, ResponseCookieStore, parseCookieHeader, serializeCookie };
+module.exports = { CookieStore, RequestCookieStore, ResponseCookieStore, parseCookieHeader, serializeCookie };

package/compat/data-cache.cjs

@@ -1,6 +1,7 @@
 'use strict';
 const { AsyncLocalStorage, AsyncResource } = require('node:async_hooks');
 const http = require('node:http');
+const cacheWire = require('./cache-wire.cjs');
 const { setTimeout: delay } = require('node:timers/promises');
 const { trackStaticDependency } = require('./static-generation.cjs');
 const diagnostics = require('./diagnostics.cjs');
@@ -21,7 +22,8 @@ const rpcScope = new AsyncResource('prnext-cache-transport');
 // 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) {
+function localRpc(target, parts, signal, binary) {
+  const length = parts.reduce((sum,part)=>sum+Buffer.byteLength(part),0);
   return rpcScope.runInAsyncScope(() => new Promise((resolve, reject) => {
     let settled = false;
     const finish = (error, value) => {
@@ -31,7 +33,7 @@ function localRpc(target, body, signal) {
       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) },
+      headers: { 'content-type': binary ? cacheWire.TYPE : 'application/json', authorization: `Bearer ${target.token}`, 'content-length': length },
     }, response => {
       let size = 0;
       const chunks = [];
@@ -43,14 +45,14 @@ function localRpc(target, body, signal) {
       });
       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 }); }
+        try { finish(null, { ok, status: response.statusCode, value: ok ? (binary ? (response.headers['content-type'] === cacheWire.TYPE ? cacheWire.decode(Buffer.concat(chunks,size)) : (()=>{throw new Error('Cache protocol mismatch')})()) : 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);
+    if (signal?.aborted) abort(); else { request.cork(); for(const part of parts) request.write(part); request.end(); request.uncork(); }
   }));
 }
 
@@ -149,9 +151,10 @@ async function acquireExternalCacheLease(key, 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 binary = local && process.env.PRNEXT_CACHE_PROTOCOL === '2';
+  const body = binary ? cacheWire.encode(operation) : [JSON.stringify(operation.value === undefined ? operation : { ...operation, value: bufferValue(operation.value).toString('base64') })];
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(new DOMException('The operation was aborted due to timeout', 'TimeoutError')), 5000);
   timer.unref();
@@ -159,10 +162,10 @@ async function rpc(target, operation, signal) {
     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, {
+      const response = local ? await localRpc(target, body, operationSignal, binary) : await nativeFetch(target.url, {
         method: 'POST',
         headers: { 'content-type': 'application/json', authorization: `Bearer ${target.token}` },
-        body,
+        body: body[0],
         signal: operationSignal,
       });
       // The deadline covers the JSON body as well as response headers. A
@@ -198,6 +201,7 @@ function bufferValue(value) {
   return Buffer.isBuffer(value) ? value : Buffer.from(value.buffer, value.byteOffset, value.byteLength);
 }
 function decodeValue(value) {
+  if (Buffer.isBuffer(value)) { if(value.length > MAX_CACHE_VALUE_BYTES) throw new Error('Invalid PRNext data cache value'); return 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');
@@ -247,7 +251,7 @@ async function compute(target, key, lease, producer, options) {
       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,
+        const result = await rpc(target, { op: 'commit', key, lease, value: bytes, 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 {

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

@@ -2,6 +2,8 @@
 import type { ComponentType } from 'react';
 import type { IncomingMessage, ServerResponse } from 'node:http';
 export type { Metadata, Viewport, ResolvingMetadata, ResolvingViewport, MetadataRoute } from './metadata.cjs';
+export {route} from './typed-route.cjs';
+export type {Route, RoutePattern, RouteParameters} from './typed-route.cjs';
 
 export interface InstantSample {
   cookies?: Array<{name: string; value: string | null}>;
@@ -11,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};
@@ -115,24 +124,39 @@ 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 };
-  /** Next dev page-retention hints; PRNext builds all routes without that eviction queue. */
+  /** 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 };
-  /** Disable the Next development indicator. Error overlays and Fast Refresh remain enabled. */
-  devIndicators?: false;
+  /** PRNext development menu; bottom-left by default. false hides it without disabling errors or Fast Refresh. */
+  devIndicators?: false | { position?: 'bottom-right' | 'bottom-left' | 'top-right' | 'top-left' };
   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;
-  /** Enabled React Compiler transforms are not implemented. */
-  reactCompiler?: false;
-  /** Typed route generation and validation are not implemented. */
-  typedRoutes?: 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. */
+  cssEngine?: 'auto'|'postcss'|'lightningcss';
   /** Production checks use the project's installed TypeScript without emitting files. */
-  typescript?: { ignoreBuildErrors?: boolean; tsconfigPath?: string };
+  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[];
@@ -190,11 +214,66 @@ 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};
+  dispose(): Promise<void>;
+}
+export function createBuilder(projectRoot: string, options?: {envMode?: 'production' | 'test'}): Promise<ProductionBuilder>;
 export interface StaticBuildResult extends BuildResult { files: number; bytes: number; }
 export function build(projectRoot: string, options: StaticBuildOptions & { adapter: 'static' }): Promise<StaticBuildResult>;
-export function build(projectRoot: string, options?: { adapter?: 'react'; dev?: boolean; envMode?: 'production' | 'development' | 'test' }): Promise<BuildResult>;
+/** Detect a completed browser output or a PRNext React project; does not run another builder. */
+export function build(projectRoot: string, options: { adapter: 'auto'; dev?: false; spa?: boolean }): Promise<BuildResult | StaticBuildResult>;
+export function build(projectRoot: string, options?: { adapter?: 'react'; dev?: boolean; incremental?: boolean; envMode?: 'production' | 'development' | 'test' }): Promise<BuildResult>;
 export function buildStatic(projectRoot: string, options?: StaticBuildOptions): Promise<StaticBuildResult>;
 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/link.d.cts

@@ -1,7 +1,8 @@
 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;
+import type {Route,TypedUrlObject} from './typed-route.cjs';
+export interface LinkProps<T extends string=string> extends Omit<AnchorHTMLAttributes<HTMLAnchorElement>, 'href'> {
+  href: Route<T> | TypedUrlObject;
   as?: string | UrlObject;
   replace?: boolean;
   scroll?: boolean;
@@ -13,5 +14,5 @@ export interface LinkProps extends Omit<AnchorHTMLAttributes<HTMLAnchorElement>,
   children?: ReactNode;
   onNavigate?: (event: { preventDefault(): void }) => void;
 }
-declare const Link: ForwardRefExoticComponent<LinkProps & RefAttributes<HTMLAnchorElement>>;
+declare function Link<T extends string>(props:LinkProps<T> & RefAttributes<HTMLAnchorElement>): import('react').ReactElement|null;
 export 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 };