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

package/compat/app-layout-context.cjs

@@ -1,8 +1,53 @@
 'use client';
 'use strict';
 const React = require('react');
+const { AppRouterContext } = require('./app-context.cjs');
 const LayoutContext = React.createContext({ children: [] });
 const LayoutCacheContext = React.createContext(null);
+const ActivityCacheContext = React.createContext(null);
+
+function ActivitySlot({ identity, children, authorizationKey }) {
+  const retention = React.useContext(ActivityCacheContext);
+  authorizationKey ??= retention?.authorizationKey;
+  const router = React.useContext(AppRouterContext);
+  const epoch = retention?.epoch ?? 0;
+  const authorizationEpoch = retention?.authorizationEpoch ?? 0;
+  const registrations = React.useRef(new Set());
+  const serial = React.useRef(0);
+  const [saved, setSaved] = React.useState(() => ({ epoch, authorizationEpoch, active: identity, entries: new Map() }));
+  let entries = saved.entries;
+  const current = entries.get(identity);
+  if (saved.epoch !== epoch || saved.authorizationEpoch !== authorizationEpoch || current?.children !== children || current?.router !== router || current?.authorizationKey !== authorizationKey) {
+    const sameAuthorization = saved.authorizationEpoch === authorizationEpoch && !(current?.authorizationKey && authorizationKey && current.authorizationKey !== authorizationKey);
+    entries = saved.epoch === epoch && sameAuthorization ? new Map(entries) : new Map();
+    const preserve = current && saved.authorizationEpoch === authorizationEpoch && (sameAuthorization && (saved.epoch === epoch || saved.active === identity)
+      || !retention?.strictAuthorization && saved.active === identity);
+    entries.set(identity, { children, router, authorizationKey, token: preserve ? current.token : {}, reactKey: preserve ? current.reactKey : ++serial.current });
+    setSaved({ epoch, authorizationEpoch, active: identity, entries });
+  }
+  React.useLayoutEffect(() => {
+    const cache = retention?.cache;
+    if (!cache) return;
+    const inactive = new Set([...entries].filter(([key]) => key !== identity).map(([, entry]) => entry.token));
+    for (const token of registrations.current) if (!inactive.has(token)) cache.release(token);
+    for (const [key, entry] of entries) {
+      if (key === identity) cache.release(entry.token);
+      else cache.retain(entry.token, () => setSaved(previous => {
+        if (!previous.entries.has(key)) return previous;
+        const next = new Map(previous.entries); next.delete(key); return { ...previous, entries: next };
+      }));
+    }
+    registrations.current = inactive;
+  }, [entries, identity, retention?.cache]);
+  React.useLayoutEffect(() => () => {
+    for (const token of registrations.current) retention?.cache.release(token);
+    registrations.current.clear();
+  }, [retention?.cache]);
+  // Identical boundary structure during SSR and hydration. Hidden branches get
+  // their original router context and their effects are disconnected by React.
+  return [...entries].map(([key, entry]) => React.createElement(React.Activity, { key: entry.reactKey, mode: key === identity ? 'visible' : 'hidden' },
+    React.createElement(AppRouterContext.Provider, { value: key === identity ? router : entry.router }, entry.children)));
+}
 
 function LayoutProvider({ id, segments, children }) {
   const cache = React.useContext(LayoutCacheContext);
@@ -13,15 +58,20 @@ function LayoutProvider({ id, segments, children }) {
   return React.createElement(LayoutContext.Provider, { value: current }, children);
 }
 
-function LayoutSlot({ id, preserve, children }) {
+function LayoutSlot({ id, preserve, children, activityKey, activityPreserve, authorizationKey }) {
   const cache = React.useContext(LayoutCacheContext);
   const previous = React.useRef(children);
   const current = preserve && cache && Object.hasOwn(cache.slots, id) ? cache.slots[id] : preserve ? previous.current : children;
   React.useLayoutEffect(() => { previous.current = current; if (cache && id) cache.slots[id] = current; }, [cache, id, current]);
-  return current ?? null;
+  const previousKey = React.useRef(activityKey);
+  const identity = preserve || activityPreserve ? previousKey.current : activityKey;
+  React.useLayoutEffect(() => { previousKey.current = identity; }, [identity]);
+  return activityKey === undefined ? current ?? null : React.createElement(ActivitySlot, { identity, authorizationKey }, current);
 }
 
 module.exports.LayoutContext = LayoutContext;
 module.exports.LayoutCacheContext = LayoutCacheContext;
 module.exports.LayoutProvider = LayoutProvider;
 module.exports.LayoutSlot = LayoutSlot;
+module.exports.ActivitySlot = ActivitySlot;
+module.exports.ActivityCacheContext = ActivityCacheContext;

package/compat/base64.cjs

@@ -0,0 +1,10 @@
+'use strict';
+// Native decoding avoids a JavaScript callback for each Flight byte. The loop
+// remains available on browsers that do not implement Uint8Array.fromBase64.
+function decodeBase64(value) {
+  if(typeof Uint8Array.fromBase64==='function')return Uint8Array.fromBase64(value);
+  const binary=atob(value),bytes=new Uint8Array(binary.length);
+  for(let n=0;n<binary.length;n++)bytes[n]=binary.charCodeAt(n);
+  return bytes;
+}
+module.exports={decodeBase64};

package/compat/cache-handlers.cjs

@@ -80,7 +80,9 @@ async function read(entry, context) {
       if (size > MAX_BYTES) throw new Error('CacheEntry exceeds 2 MiB');
       chunks.push(Buffer.from(value));
     }
-    return Buffer.concat(chunks, size);
+    // Buffer.from above owns each chunk even when a custom producer reuses its
+    // Uint8Array on the next pull. Keep that copy, but do not copy it twice.
+    return chunks.length===1?chunks[0]:Buffer.concat(chunks, size);
   } finally {
     if (!complete) void reader.cancel().catch(() => {});
     reader.releaseLock();
@@ -139,10 +141,19 @@ async function customCachedValue(key, kind, producer, options) {
     const timestamp = Date.now();
     const record = { revision, timestamp, work: undefined, metadata: undefined };
     work = (async () => {
+      let lease,canStore=true;
+      try {
+      if(typeof handler.acquire==='function'){
+        try{
+          lease=await call(handler,'acquire',[key,{signal:context.signal}],context);
+          const shared=await call(handler,'get',[key,tags],context);
+          if(shared){const sharedInfo=metadata(shared);if(Date.now()-sharedInfo.timestamp<Math.min(sharedInfo.expire,sharedInfo.revalidate)*1000){record.metadata=sharedInfo;options.onReadMetadata?.(sharedInfo);return await read(shared,context);}void shared.value.cancel().catch(()=>{});}
+        }catch{context.signal?.throwIfAborted();canStore=false;}
+      }
       const result = await producer();
       const info = resolveMetadata();
       record.metadata = info;
-      if (result.byteLength <= MAX_BYTES && revision === (revisions.get(handler) || 0)) {
+      if (canStore && result.byteLength <= MAX_BYTES && revision === (revisions.get(handler) || 0)) {
         try {
           const changed = await expiration(handler, [...new Set([...tags, ...info.tags])], context);
           // Many backends record Date.now() millisecond timestamps. Treat the
@@ -150,12 +161,13 @@ async function customCachedValue(key, kind, producer, options) {
           // hide an invalidation which actually happened after the read started.
           if ((changed === Infinity || changed < Math.floor(timestamp)) && revision === (revisions.get(handler) || 0)) {
             const value = stream(result);
-            try { await call(handler, 'set', [key, Promise.resolve({ value, tags: info.tags, stale: info.stale, revalidate: info.revalidate, expire: info.expire, timestamp })], context); }
+            try { await call(handler, 'set', [key, Promise.resolve({ value, tags: info.tags, stale: info.stale, revalidate: info.revalidate, expire: info.expire, timestamp }),{lease,softTags:tags}], context); }
             catch { if (!value.locked) void value.cancel().catch(() => {}); }
           }
         } catch { context.signal?.throwIfAborted(); }
       }
       return result;
+      }finally{try{await lease?.release();}catch{/* A failed cache cleanup does not replay application work. */}}
     })();
     record.work = work;
     if (pendingCount < 64) {

package/compat/cache-wire.cjs

@@ -0,0 +1,28 @@
+'use strict';
+// Versioned private framing: bounded JSON metadata followed by uninterpreted bytes.
+const TYPE = 'application/vnd.prnext.cache-v2';
+const MAX_VALUE = 2 * 1024 * 1024;
+const MAX_META = 2 * 1024 * 1024;
+function encode(operation) {
+  const { value, ...metadata } = operation;
+  if (value !== undefined && !Buffer.isBuffer(value) && !(value instanceof Uint8Array)) throw new TypeError('Cache wire values must be bytes');
+  const bytes = value === undefined ? undefined : Buffer.isBuffer(value) ? value : Buffer.from(value.buffer, value.byteOffset, value.byteLength);
+  if (bytes && (metadata.op !== 'commit' || bytes.length > MAX_VALUE)) throw new Error('Invalid cache wire value');
+  if (metadata.op === 'commit' && !bytes) throw new Error('Cache commit requires bytes');
+  const json = Buffer.from(JSON.stringify(metadata));
+  if (json.length > MAX_META) throw new Error('Cache wire metadata exceeds limit');
+  const prefix = Buffer.allocUnsafe(4); prefix.writeUInt32BE(json.length);
+  return bytes ? [prefix, json, bytes] : [prefix, json];
+}
+function decode(bytes) {
+  if (bytes.length < 4) throw new Error('Truncated cache wire frame');
+  const length = bytes.readUInt32BE(0);
+  if (length > MAX_META || length > bytes.length - 4) throw new Error('Invalid cache wire metadata length');
+  const value = JSON.parse(bytes.subarray(4, 4 + length).toString('utf8'));
+  if (!value || typeof value !== 'object' || Array.isArray(value)) throw new Error('Invalid cache wire metadata');
+  const raw = bytes.subarray(4 + length);
+  if (raw.length > MAX_VALUE || (value.value !== true && raw.length) || (value.value !== undefined && value.value !== true)) throw new Error('Invalid cache wire payload');
+  if (value.value === true) value.value = raw;
+  return value;
+}
+module.exports = { TYPE, MAX_VALUE, MAX_META, encode, decode };

package/compat/cache.cjs

@@ -96,4 +96,5 @@ function unstable_noStore() {
 }
 function refresh() { cacheState(mutationContext('refresh', true)).refresh = true; }
 
-module.exports = { unstable_cache, revalidateTag, updateTag, revalidatePath, unstable_noStore, refresh, cacheTag, cacheLife };
+const { navigation, prefetch } = require('./navigation-stages.cjs');
+module.exports = { unstable_cache, revalidateTag, updateTag, revalidatePath, unstable_noStore, refresh, cacheTag, cacheLife, navigation, prefetch };

package/compat/cache.d.cts

@@ -34,3 +34,7 @@ export function updateTag(tag: string): void;
 export function revalidatePath(path: string, type?: 'page' | 'layout'): void;
 export function unstable_noStore(): void;
 export function refresh(): void;
+/** Defer runtime work until navigation, while allowing static prerenders. */
+export function navigation(): Promise<void>;
+/** Defer runtime work until a per-link prefetch or navigation. */
+export function prefetch(): Promise<void>;

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,152 @@
+'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();}})};
+  // A short first chunk always selects ordinary Flight. Do not build a base
+  // index that this response cannot use, or wait for a later streaming chunk.
+  let index=first.value.length>=WINDOW&&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;