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

package/build/typescript-toolchain.mjs

@@ -0,0 +1,19 @@
+import {readFile,stat} from 'node:fs/promises';
+import {createRequire} from 'node:module';
+import path from 'node:path';
+
+// Select from the application's installation, never from the framework's own
+// development dependencies. Native TypeScript deliberately lacks the old API.
+export async function resolveTypeScript(root) {
+  const require=createRequire(path.join(root,'package.json'));
+  const manifest=require.resolve('typescript/package.json');
+  const metadata=JSON.parse(await readFile(manifest,'utf8'));
+  const major=Number(/^([0-9]+)\./.exec(metadata.version)?.[1]);
+  if(!Number.isInteger(major))throw new Error('The installed TypeScript package has no valid version.');
+  if(major<7)return {native:false,compiler:require.resolve('typescript'),version:metadata.version};
+  const entry=typeof metadata.bin==='string'?metadata.bin:metadata.bin?.tsc;
+  if(typeof entry!=='string'||!entry)throw new Error('The installed TypeScript package has no tsc command. Reinstall TypeScript with its optional native dependencies.');
+  const directory=path.dirname(manifest),bin=path.resolve(directory,entry);
+  if(!bin.startsWith(directory+path.sep)||!(await stat(bin)).isFile())throw new Error('The installed TypeScript tsc command is invalid.');
+  return {native:true,compiler:bin,version:metadata.version};
+}

package/build/typescript.mjs

@@ -1,9 +1,10 @@
 import { stat } from 'node:fs/promises';
-import { createRequire } from 'node:module';
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
 import { fileURLToPath } from 'node:url';
 import path from 'node:path';
+import {resolveTypeScript} from './typescript-toolchain.mjs';
+import {checkNativeTypeScript} from './typescript-native.mjs';
 
 const execute = promisify(execFile);
 
@@ -37,11 +38,12 @@ export async function checkTypeScript(root, config, { dev = false, tsconfig, for
   if (!force && (dev || !config.typescript || config.typescript.ignoreBuildErrors)) return;
   tsconfig ??= await projectTsconfig(root, config);
   if (!tsconfig) throw new Error('TypeScript checking was explicitly enabled, but tsconfig.json does not exist. Create a TypeScript configuration, set typescript.tsconfigPath to an existing configuration, or explicitly set typescript.ignoreBuildErrors: true if types are checked separately.');
-  let compiler;
-  try { compiler = createRequire(path.join(root, 'package.json')).resolve('typescript'); }
+  let toolchain;
+  try { toolchain = await resolveTypeScript(root); }
   catch (error) { throw new Error('TypeScript checking requires typescript in the project. Install it as a dev dependency, or explicitly set typescript.ignoreBuildErrors: true if a separate process checks types.', { cause: error }); }
   try {
-    await execute(process.execPath, [fileURLToPath(new URL('./typescript-check.mjs', import.meta.url)), compiler, tsconfig], {
+    if(toolchain.native){await checkNativeTypeScript(toolchain.compiler,tsconfig,root);return;}
+    await execute(process.execPath, [fileURLToPath(new URL('./typescript-check.mjs', import.meta.url)), toolchain.compiler, tsconfig], {
       cwd: root, windowsHide: true, maxBuffer: 4 * 1024 * 1024,
     });
   } catch (error) {

package/build/webpack-graph.mjs

@@ -233,7 +233,7 @@ async function createGraphSession(root,{webpack,reusable,stage}) {
         cssChunkFilename:'style-[contenthash:16].css',module:true,library:{type:'module'},chunkFormat:'module',chunkLoading:'import',
         publicPath:target==='node'?'./':state.assetBase+'/',environment:{module:true,dynamicImport:true},compareBeforeEmit:false,clean:false},
       performance:false,
-      optimization:{minimize:!!options.minify,minimizer:[{apply(compiler){
+      optimization:{minimize:!!options.minify,mangleExports:options.minify?'size':false,minimizer:[{apply(compiler){
         compiler.hooks.compilation.tap('PRNextMinify',compilation=>{
           compilation.hooks.processAssets.tapPromise({name:'PRNextMinify',stage:webpack.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_SIZE},async()=>{
             // Sequential native esbuild transforms avoid a Terser worker pool.
@@ -247,7 +247,7 @@ async function createGraphSession(root,{webpack,reusable,stage}) {
           });
         });
       }}],runtimeChunk:options.splitting?{name:()=>runtime}:false,
-        splitChunks:options.splitting?{chunks:'all',minSize:0,cacheGroups:{default:false,defaultVendors:false,shared:{minChunks:2,test:module=>!module.type.startsWith('css'),name:false}}}:false},
+        splitChunks:options.splitting?{chunks:'all',minSize:0,cacheGroups:{default:false,defaultVendors:false,shared:{minChunks:2,reuseExistingChunk:true,test:module=>!module.type.startsWith('css'),name:false}}}:false},
       resolve:{alias:config.resolution.resolveAlias || {},conditionNames:[...(options.conditions || []),'...'],extensions:config.resolution.resolveExtensions || ['.tsx','.ts','.jsx','.js','.mjs','.json'],fullySpecified:false},
       module:{unsafeCache:false,rules:[{test:/./,type:'javascript/auto',enforce:'post',use:[{loader:loaderPath,options:{bridge:bridgeId}}]},
         {test:/\.json$/,type:'json'},{test:/\.(?:css|scss|sass)$/,type:'css'},
@@ -379,7 +379,10 @@ async function createGraphSession(root,{webpack,reusable,stage}) {
       for(const name of previousOutputs)if(!currentOutputs.has(name))await discardPrivateFile(path.join(actualOut,name),actualOut);
       previousOutputs.clear();for(const name of currentOutputs)previousOutputs.add(name);
     }
-    return {errors:[],warnings:[],metafile:{inputs,outputs},...(options.write===false?{outputFiles}:{})};
+    // This compatibility metafile does not yet encode webpack's runtime and
+    // async chunk-group edges. Consumers must not mistake empty import lists
+    // for a complete initial browser graph.
+    return {errors:[],warnings:[],metafile:{inputs,outputs,initialGraphComplete:false},...(options.write===false?{outputFiles}:{})};
   } finally {
     active.delete(bridgeId);
     for(const file of virtualFiles)if(!usedVirtualFiles.has(file)){virtualFiles.delete(file);await discardPrivateFile(file,home);}

package/build/worker-memory.mjs

@@ -0,0 +1,9 @@
+export function validateWorkerMemory(value) {
+  if (value === undefined || value === false) return undefined;
+  if (!value || typeof value !== 'object' || Array.isArray(value) ||
+      Object.keys(value).some(key => key !== 'maxRssMb') ||
+      !Number.isSafeInteger(value.maxRssMb) || value.maxRssMb < 64 || value.maxRssMb > 65536) {
+    throw new TypeError('workerMemory must be false or { maxRssMb: 64..65536 }');
+  }
+  return { maxRssMb: value.maxRssMb };
+}

package/cli.mjs

@@ -11,6 +11,9 @@ const help = `PRNext ${packageManifest.version}
 
 Use prnext for portable scripts; prn is a shortcut on compatible shells.
 
+  prnext create <directory>            Create a project and install dependencies
+  prnext create <directory> --no-install  Prepare project files without installing
+  prnext create --help                 TypeScript, JavaScript and creation options
   prnext build [directory]              Build React/TypeScript and static HTML
   prnext build [directory] --watch      Incremental production rebuilds on changes
   prnext build [directory] --adapter static [--from dist] [--spa]
@@ -40,6 +43,7 @@ Use prnext for portable scripts; prn is a shortcut on compatible shells.
   prnext typecheck [directory] [--json]  Generate types and check TypeScript without building
   prnext inspect [directory] [--json|--otlp] Explain routes, health and sampled timings
   prnext analyze [directory] [--json] [--max-js 150]  Browser bundles and budget (kB)
+  prnext compiler [directory] [--json]  React Compiler results from the last successful build
   prnext host [prnext.host.json]         Host built apps by hostname; wake on demand
   prnext host [config] --check           Validate hosting configuration and builds
   prnext host [config] --status [--json]  Show memory, process and idle status
@@ -69,10 +73,12 @@ Analysis options: --metric raw|gzip|brotli (default raw), --baseline analysis.js
   --max-increase-bytes 1024 --max-increase-percent 5
   --budgets budgets.json               Exact route keys with maxJs (kB),
                                        maxIncreaseBytes and/or maxIncreasePercent
-Analysis exit codes: 0 passed, 1 budget exceeded, 2 invalid input or missing build.
+Analysis exit codes: 0 passed, 1 budget exceeded or initial total unverifiable,
+  2 invalid input or missing build. Request-dependent totals are lower bounds.
 
 Server options: --port 3000 --hostname 127.0.0.1 --workers 1 --inspect
 Production profiles: --profile balanced|speed|memory|classic
+Render readiness: --prewarm --readiness-file /private/path/ready.json
 Worker retirement: --worker-idle-seconds 300 --lane-idle-seconds 30 --keep-warm [true|false]
 Memory favors lower RAM under concurrency, accepting more waiting and CPU per response.
 Without an option: PRNEXT_PROFILE, legacy PRNEXT_MEMORY_PROFILE=compact, then balanced.
@@ -101,6 +107,30 @@ function stop(child) {
 async function main() {
   if (['help', '--help', '-h'].includes(command)) { console.log(help); return; }
   if (['--version', '-v'].includes(command)) { console.log(packageManifest.version); return; }
+  if (command === 'create') {
+    const { createHelp, parseCreateArgs, createProject } = await import('./build/create.mjs');
+    if (argv.length === 1 && ['--help', '-h'].includes(argv[0])) { console.log(createHelp); return; }
+    const { directory, options } = parseCreateArgs(argv);
+    const controller = new AbortController();
+    let interrupted;
+    const interrupt = signal => { interrupted = signal; controller.abort(); };
+    const onInt = () => interrupt('SIGINT'), onTerm = () => interrupt('SIGTERM');
+    process.on('SIGINT', onInt); process.on('SIGTERM', onTerm);
+    try {
+      const report = await createProject(directory, { ...options, signal: controller.signal,
+        onOutput: options.json ? () => {} : (chunk, stream) => process[stream].write(chunk) });
+      if (options.json) console.log(JSON.stringify(report, null, 2));
+      else {
+        console.log(`PRNext project ${report.status}: ${report.root}`);
+        if (report.error) console.error(report.error);
+        if (!report.ok) console.log('Project files were preserved. Retry installation from this directory.');
+        if (path.resolve(process.cwd()) !== directory) console.log(`\nOpen ${report.root} in your terminal, then run:`);
+        for (const next of report.next) console.log(`  ${next}`);
+      }
+      if (!report.ok) process.exitCode = interrupted === 'SIGINT' ? 130 : interrupted === 'SIGTERM' ? 143 : 1;
+    } finally { process.removeListener('SIGINT', onInt); process.removeListener('SIGTERM', onTerm); }
+    return;
+  }
   if (command === 'docs') {
     const { executeAiDocs } = await import('./runtime/ai-docs.mjs');
     const result = await executeAiDocs(argv);
@@ -185,10 +215,28 @@ async function main() {
     if (!report.ok) process.exitCode = 1;
     return;
   }
-  if (!['build', 'start', 'dev', 'routes', 'check', 'typegen', 'typecheck', 'inspect', 'analyze', 'output'].includes(command)) throw new Error(`Unknown command: ${command}\n${help}`);
+  if (!['build', 'start', 'dev', 'routes', 'check', 'typegen', 'typecheck', 'inspect', 'analyze', 'compiler', 'output'].includes(command)) throw new Error(`Unknown command: ${command}\n${help}`);
   const args = [...argv];
   const root = path.resolve(args[0] && !args[0].startsWith('-') ? args.shift() : '.');
-  if (['check','typegen','typecheck','analyze'].includes(command) && args.some(arg => ['--help','-h'].includes(arg))) { console.log(help); return; }
+  if (['check','typegen','typecheck','analyze','compiler'].includes(command) && args.some(arg => ['--help','-h'].includes(arg))) { console.log(help); return; }
+  if(command==='compiler'){
+    try {
+      if(args.some(arg=>arg!=='--json') || args.filter(arg=>arg==='--json').length>1)throw new Error('compiler accepts only [directory] and --json');
+      const {readReactCompilerReport,printReactCompilerReport}=await import('./build/react-compiler-report.mjs');
+      const {readBuildOutput}=await import('./build/output-contract.mjs');
+      const directory=path.join(root,await readBuildDirectory(root));
+      const output=await readBuildOutput(directory);
+      if(output.adapter!=='react')throw new Error('React Compiler reports apply to React builds. This application uses the static adapter.');
+      const report=await readReactCompilerReport(directory,{buildId:output.buildId});
+      if(!report)throw new Error('No React Compiler report is available. Rebuild this application with the installed PRNext version.');
+      if(args.includes('--json'))console.log(JSON.stringify(report,null,2));else printReactCompilerReport(report,{details:true});
+    } catch(error) {
+      if(args.includes('--json'))console.log(JSON.stringify({ok:false,error:error.message}));
+      else console.error(`PRNext compiler: ${error.message}`);
+      process.exitCode=2;
+    }
+    return;
+  }
   if(command==='analyze'){
     try {
       const {analyzeBuild,printAnalysis,parseAnalysisArgs}=await import('./build/analyze.mjs');
@@ -307,7 +355,15 @@ async function main() {
       await buildStatic(root, options);
     } else {
       const { build } = await import('./build/index.mjs');
-      await build(root, { ...options, dev, envMode });
+      const result=await build(root, { ...options, dev, envMode });
+      if(!dev&&result.compilationCache?.hits){
+        const {hits,reusedBytes}=result.compilationCache;
+        console.log(`Compilation cache: ${hits} ${hits===1?'graph':'graphs'} reused (${Math.ceil(reusedBytes/1024)} KiB).`);
+      }
+      if(result.reactCompilerReport?.enabled){
+        const {printReactCompilerReport}=await import('./build/react-compiler-report.mjs');
+        printReactCompilerReport(result.reactCompilerReport,{details:false});
+      }
     }
     console.log(`PRNext built ${root} in ${((performance.now() - started) / 1000).toFixed(2)}s`);
     return;

package/compat/activity-cache.cjs

@@ -0,0 +1,26 @@
+'use strict';
+
+// A shared budget across layout slots, rather than a separate page budget at
+// every nesting level. Only inactive branches enter this registry.
+function createActivityCache({ limit = 4, ttl = 120000, now = Date.now, schedule = setTimeout, cancel = clearTimeout } = {}) {
+  const entries = new Map(); let timer;
+  function arm() {
+    cancel(timer); timer = undefined;
+    if (entries.size) {
+      timer = schedule(prune, Math.max(1, Math.min(...[...entries.values()].map(entry => entry.expires)) - now()));
+      timer?.unref?.();
+    }
+  }
+  function prune() {
+    for (const [key, entry] of entries) if (entry.expires <= now()) { entries.delete(key); entry.evict(); }
+    while (entries.size > limit) { const [key, entry] = entries.entries().next().value; entries.delete(key); entry.evict(); }
+    arm();
+  }
+  return {
+    retain(key, evict) { if (!entries.has(key)) entries.set(key, { evict, expires: now() + ttl }); prune(); },
+    release(key) { entries.delete(key); arm(); },
+    clear() { const previous = [...entries.values()]; entries.clear(); cancel(timer); timer = undefined; for (const entry of previous) entry.evict(); },
+    get size() { return entries.size; },
+  };
+}
+module.exports = { createActivityCache };

package/compat/after.cjs

@@ -4,11 +4,11 @@ const { AsyncLocalStorage } = require('node:async_hooks');
 function after(task) {
   const context = require('./headers.cjs').currentRequest();
   if (require('./data-cache.cjs').inCacheScope()) throw new Error('after() cannot be registered inside a cache scope');
-  if (!context.afterScope || !['route', 'action', 'after'].includes(context.phase)) throw new Error('after() currently requires a Node Route Handler or Server Action in PRNext. Server Component and Edge after() lifecycles are not implemented.');
+  if (!context.afterScope || !['route', 'action', 'render', 'after'].includes(context.phase)) throw new Error('after() requires a Node Server Component, Route Handler or Server Action. Edge after() is not implemented.');
   context.afterScope.add(task, context, AsyncLocalStorage.snapshot());
 }
 
-function createAfterScope({ signal, timeoutMs = 25000, onTimeout = () => {}, onComplete, report = error => console.error('[prnext] after() failed:', error?.stack || error) } = {}) {
+function createAfterScope({ signal, timeoutMs = 25000, onTimeout = () => {}, onComplete, onRegistered, report = error => console.error('[prnext] after() failed:', error?.stack || error) } = {}) {
   const queue = []; let count = 0, closed = false, finishing;
   const deadline = Date.now() + timeoutMs;
   const track = promise => signal?.[Symbol.for('prnext.request-work')]?.(promise, { timeoutMs: Math.max(1, deadline - Date.now()) });
@@ -18,6 +18,7 @@ function createAfterScope({ signal, timeoutMs = 25000, onTimeout = () => {}, onC
       if (closed) throw new Error('after() request has already completed');
       if (typeof task !== 'function' && (!task || typeof task.then !== 'function')) throw new TypeError('after() expects a callback or a Promise');
       if (++count > 128) throw new Error('after() exceeds 128 tasks per request');
+      if (count === 1) onRegistered?.();
       const pending = typeof task === 'function' ? null : observe(task);
       if (pending) track(pending);
       queue.push({ task: pending ? null : task, pending, context, run });
@@ -27,8 +28,9 @@ function createAfterScope({ signal, timeoutMs = 25000, onTimeout = () => {}, onC
         try {
           while (queue.length) {
             const item = queue.shift(), remaining = deadline - Date.now();
-            if (remaining <= 0) { const error = new Error('after() exceeded the request maxDuration'); report(error); onTimeout(error); break; }
+            if (remaining <= 0) { const error = new Error('after() exceeded the request maxDuration'); await item.run(()=>report(error)); onTimeout(error); break; }
             const abort = new AbortController();
+            item.context.afterRestricted ||= item.context.phase === 'render';
             item.context.cookies._mutable = false;
             item.context.phase = 'after';
             item.context.signal = abort.signal;
@@ -38,7 +40,7 @@ function createAfterScope({ signal, timeoutMs = 25000, onTimeout = () => {}, onC
             let timer;
             try {
               const outcome = await Promise.race([work, new Promise(resolve => { timer = setTimeout(() => { const error = new Error('after() exceeded the request maxDuration'); abort.abort(error); resolve({ error }); }, remaining); })]);
-              if ('error' in outcome) report(outcome.error);
+              if ('error' in outcome) await item.run(()=>report(outcome.error));
               if (abort.signal.aborted) { onTimeout(outcome.error); break; }
             } finally { clearTimeout(timer); item.context.cacheState.closed = true; await onComplete?.(item.context); }
           }

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

@@ -139,10 +139,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 +159,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 {