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

package/runtime/pages-navigation.mjs

@@ -4,7 +4,10 @@ import { rewriteQuery } from '../compat/rewrite.cjs';
 import { normalizeBasePath, removeBasePath } from '../compat/paths.cjs';
 import { publicNavigationURL, isApplicationURL } from './client-navigation.mjs';
 import DefaultError from '../compat/error.cjs';
+import { createPrefetchScheduler, prefetchCacheVictim } from './prefetch-scheduler.mjs';
 import { applicationProps, createInitialPropsRunner } from './pages-initial-props.mjs';
+import { matchPagePattern } from './route-pattern.mjs';
+export { matchPagePattern } from './route-pattern.mjs';
 
 const PREFETCH_LIMIT = 8;
 const PREFETCH_TTL = 30_000;
@@ -51,33 +54,6 @@ export function pageRouterSnapshot(router, requestURL, visibleURL, rewrite) {
     ...(rewrite ? { rewrite } : {}) };
 }
 
-export function matchPagePattern(pattern, pathname) {
-  let segments;
-  try { segments = pathname.replace(/\/+$/, '').split('/').slice(1).map(decodeURIComponent); }
-  catch { return null; }
-  if (segments.length === 1 && !segments[0]) segments = [];
-  if (segments.some(segment => !segment || /[/\\\0]/.test(segment) || segment === '.' || segment === '..')) return null;
-  const parts = pattern === '/' ? [] : pattern.split('/').slice(1), params = Object.create(null), rank = [];
-  let index = 0;
-  for (const part of parts) {
-    const optional = /^\[\[\.\.\.([^\]]+)\]\]$/.exec(part);
-    const catchall = /^\[\.\.\.([^\]]+)\]$/.exec(part);
-    const parameter = /^\[([^\]]+)\]$/.exec(part);
-    if (optional || catchall) {
-      if (catchall && index === segments.length) return null;
-      if (index !== segments.length) params[(optional || catchall)[1]] = segments.slice(index);
-      index = segments.length; rank.push(optional ? 0 : 1);
-    } else if (parameter) {
-      if (index === segments.length) return null;
-      params[parameter[1]] = segments[index++]; rank.push(2);
-    } else {
-      if (segments[index++] !== part) return null;
-      rank.push(3);
-    }
-  }
-  return index === segments.length ? { params, rank } : null;
-}
-
 export function resolvePageRoute(manifest, pathname) {
   let winner;
   for (const [routes, pages] of [[manifest.routes, true], [manifest.nonPagesRoutes || [], false]]) {
@@ -129,7 +105,8 @@ export function createPagesNavigation({ initial, initialRoute, manifestUrl, read
   initial = undefined;
   let manifestPromise, active, renderingError, sequence = 0, beforePop = () => true;
   let currentKey = win.history.state?.__prnextPages?.key || 0, nextKey = currentKey + 1;
-  const prefetches = new Map(), queue = []; let prefetchRunning = 0, prefetchBytes = 0;
+  const prefetches = new Map(), scheduler = createPrefetchScheduler({ window: win, document: doc });
+  let prefetchBytes = 0;
 
   function assetURL(value) {
     const url = new URL(value, win.location.href);
@@ -147,7 +124,7 @@ export function createPagesNavigation({ initial, initialRoute, manifestUrl, read
       const abort = new AbortController(), timer = setTimeout(() => abort.abort(), 30_000);
       try {
         const value = JSON.parse(await consume(await fetchAsset(manifestUrl, abort.signal), ASSET_LIMIT));
-        if (value.buildId !== buildId || !Array.isArray(value.routes) || value.routes.length > 10_000) throw new Error('Invalid Pages manifest');
+        if (value.buildId !== buildId || current.deploymentId && value.deploymentId !== current.deploymentId || !Array.isArray(value.routes) || value.routes.length > 10_000) throw new Error('Invalid Pages manifest');
         for (const route of [...value.routes, ...Object.values(value.errors || {}).filter(Boolean)]) {
           if (typeof route.pattern !== 'string' || !Array.isArray(route.css)) throw new Error('Invalid page route');
           assetURL(route.client); for (const css of route.css) assetURL(css);
@@ -278,44 +255,45 @@ export function createPagesNavigation({ initial, initialRoute, manifestUrl, read
     prefetchBytes -= entry.bytes || 0; entry.bytes = 0;
     if (abort) entry.abort.abort(); else entry.consumed = true;
   }
-  function pumpPrefetch() {
-    while (prefetchRunning < 2 && queue.length) {
-      const entry = queue.shift();
-      if (entry.abort.signal.aborted) { entry.resolve(); continue; }
-      prefetchRunning++;
-      (async () => {
-        const map = await abortable(manifest(), entry.abort.signal), matched = resolvePageRoute(map, internalPath(entry.request));
-        if (!matched?.pages) return;
-        // Fetch rather than evaluate speculative modules: fetch is cancellable,
-        // whereas the browser's import() cannot cancel a blocked module request.
-        await consume(await fetchAsset(matched.route.client, entry.abort.signal), ASSET_LIMIT);
-        if (entry.abort.signal.aborted) return;
-        // Warm browser HTTP caches without applying another page's CSS early.
-        for (const css of matched.route.css) await consume(await fetchAsset(css, entry.abort.signal), ASSET_LIMIT);
-        if (matched.route.ssg) {
-          const decoded = await requestData(entry.request, entry.abort.signal, true);
-          if (entry.abort.signal.aborted || (!prefetches.has(entry.key) && !entry.consumed) || decoded.cacheable === false) return;
-          entry.data = decoded;
-          if (entry.consumed) return;
-          entry.bytes = decoded.bytes || 0; prefetchBytes += entry.bytes;
-          while (prefetchBytes > PREFETCH_BYTES) dropPrefetch(prefetches.keys().next().value);
-        }
-      })().catch(() => { dropPrefetch(entry.key); }).finally(() => { prefetchRunning--; entry.resolve(); pumpPrefetch(); });
+  async function runPrefetch(entry) {
+    const map = await abortable(manifest(), entry.abort.signal), matched = resolvePageRoute(map, internalPath(entry.request));
+    if (!matched?.pages) return;
+    // Fetch rather than evaluate speculative modules: fetch can be cancelled,
+    // whereas import() can leave an uncancellable module request in flight.
+    await consume(await fetchAsset(matched.route.client, entry.abort.signal), ASSET_LIMIT);
+    if (entry.abort.signal.aborted) return;
+    for (const css of matched.route.css) await consume(await fetchAsset(css, entry.abort.signal), ASSET_LIMIT);
+    if (matched.route.ssg) {
+      const decoded = await requestData(entry.request, entry.abort.signal, true);
+      if (entry.abort.signal.aborted || (prefetches.get(entry.key) !== entry && !entry.consumed) || decoded.cacheable === false) return;
+      entry.data = decoded;
+      if (entry.consumed) return;
+      entry.bytes = decoded.bytes || 0; prefetchBytes += entry.bytes;
+      while (prefetchBytes > PREFETCH_BYTES) {
+        const victim = prefetchCacheVictim([...prefetches].filter(([, value]) => value.bytes > 0), 1);
+        if (victim === undefined) break;
+        dropPrefetch(victim);
+      }
     }
   }
-  function prefetch(url, as, options) {
+  function prefetch(url, as, options = {}) {
     let request;
     try { ({ request } = targets(url, as, options)); } catch { return Promise.resolve(); }
     if (!isApplicationURL(request, win.location.origin, basePath) || process.env.NODE_ENV !== 'production') return Promise.resolve();
     request.hash = ''; const key = request.href;
-    if (prefetches.has(key)) return prefetches.get(key).promise;
-    while (prefetches.size >= PREFETCH_LIMIT) dropPrefetch(prefetches.keys().next().value);
-    // Queued cancelled entries must not grow with an unbounded list of hovered links.
-    for (let index = queue.length - 1; index >= 0; index--) if (queue[index].abort.signal.aborted) { queue[index].resolve(); queue.splice(index, 1); }
-    const entry = { key, request, abort: new AbortController() };
-    entry.promise = new Promise(resolve => { entry.resolve = resolve; });
+    const priority = options.priority === 'viewport' ? 0 : 1;
+    const previous = prefetches.get(key);
+    if (previous && !previous.abort.signal.aborted) { previous.priority = Math.max(previous.priority, priority); previous.task.promote(options.priority); return previous.promise; }
+    if (previous) dropPrefetch(key);
+    const victim = prefetches.size >= PREFETCH_LIMIT ? prefetchCacheVictim(prefetches, priority) : undefined;
+    if (prefetches.size >= PREFETCH_LIMIT && victim === undefined) return Promise.resolve();
+    const entry = { key, request, priority, abort: new AbortController() };
+    entry.task = scheduler.schedule(() => runPrefetch(entry), { abort: entry.abort, priority: options.priority });
+    if (!entry.task) return Promise.resolve();
+    if (victim !== undefined) dropPrefetch(victim);
+    entry.promise = entry.task.promise.catch(() => { if (prefetches.get(key) === entry) dropPrefetch(key); });
     entry.timer = setTimeout(() => dropPrefetch(key), PREFETCH_TTL);
-    prefetches.set(key, entry); queue.push(entry); pumpPrefetch(); return entry.promise;
+    prefetches.set(key, entry); return entry.promise;
   }
   function cancelActive() {
     if (!active) return;
@@ -332,6 +310,9 @@ export function createPagesNavigation({ initial, initialRoute, manifestUrl, read
     cancelActive(); renderingError?.abort.abort(); renderingError = undefined; saveScroll();
     const job = { id: ++sequence, abort: new AbortController(), asPath: destination.pathname + destination.search + destination.hash, shallow: !!options.shallow };
     active = job;
+    const prefetchKey = new URL(request); prefetchKey.hash = '';
+    const releaseNavigation = scheduler.navigation(prefetches.get(prefetchKey.href)?.task);
+    job.abort.signal.addEventListener('abort', releaseNavigation, { once: true });
     const timer = setTimeout(() => job.abort.abort(new Error('Page navigation timed out')), 30_000);
     const hashOnly = destination.pathname === currentURL.pathname && destination.search === currentURL.search &&
       (destination.hash !== currentURL.hash || !!destination.hash) && !options.shallow;
@@ -459,7 +440,7 @@ export function createPagesNavigation({ initial, initialRoute, manifestUrl, read
       job.finished = true; active = undefined;
       events.emit('routeChangeError', error, job.asPath, { shallow: job.shallow });
       hard(destination, options.replace || options.pop); return false;
-    } finally { clearTimeout(timer); }
+    } finally { clearTimeout(timer); job.abort.signal.removeEventListener('abort', releaseNavigation); releaseNavigation(); }
   }
   async function reportRenderError(error, failedView) {
     if (failedView !== current && (failedView.clientSnapshot || failedView.Page !== current.Page || failedView.props !== current.props)) return false;
@@ -550,7 +531,11 @@ export function createPagesNavigation({ initial, initialRoute, manifestUrl, read
   };
   let frame;
   const onScroll = () => { if (frame !== undefined) return; frame = win.requestAnimationFrame(() => { frame = undefined; saveScroll(); }); };
-  const pagehide = () => { saveScroll(); active?.abort.abort(); renderingError?.abort.abort(); for (const key of prefetches.keys()) dropPrefetch(key); };
+  const pagehide = () => {
+    saveScroll(); cancelActive(); active = undefined;
+    renderingError?.abort.abort(); renderingError = undefined;
+    for (const key of prefetches.keys()) dropPrefetch(key);
+  };
   win.history.replaceState(historyState(currentURL, currentRequest, currentKey, {}, [win.scrollX, win.scrollY]), '', currentURL.href);
   win.history.scrollRestoration = 'manual';
   win.addEventListener('popstate', popstate); win.addEventListener('scroll', onScroll, { passive: true }); win.addEventListener('pagehide', pagehide);
@@ -565,6 +550,6 @@ export function createPagesNavigation({ initial, initialRoute, manifestUrl, read
       await navigate(currentRequest, currentURL, { replace: true, scroll: false, devRefresh:true });
     } } : {}),
     refreshFallback,
-    dispose() { pagehide(); win.removeEventListener('popstate', popstate); win.removeEventListener('scroll', onScroll); win.removeEventListener('pagehide', pagehide); if (frame !== undefined) win.cancelAnimationFrame(frame); },
+    dispose() { pagehide(); scheduler.dispose(); win.removeEventListener('popstate', popstate); win.removeEventListener('scroll', onScroll); win.removeEventListener('pagehide', pagehide); if (frame !== undefined) win.cancelAnimationFrame(frame); },
   };
 }

package/runtime/prefetch-scheduler.mjs

@@ -0,0 +1,110 @@
+const INTENT = 1;
+const abortError = () => Object.assign(new Error('Speculative navigation cancelled'), { name: 'AbortError' });
+
+// The completed-result cache obeys the same priority as the producer queue.
+// Otherwise a viewport scan could evict the hovered route immediately after
+// the scheduler had correctly protected its request.
+export function prefetchCacheVictim(cache, priority) {
+  let candidate;
+  for (const [key, entry] of cache) {
+    if (entry.abort.signal.aborted) return key;
+    if (!candidate || entry.priority < candidate[1].priority) candidate = [key, entry];
+  }
+  return candidate && candidate[1].priority <= priority ? candidate[0] : undefined;
+}
+
+// Speculative work never competes with a committed navigation. The same policy
+// is used by both routers; data and authorization remain in their own caches.
+export function createPrefetchScheduler({ window: win = globalThis.window, document: doc = globalThis.document,
+  concurrency = 2, limit = 8 } = {}) {
+  const tasks = new Set();
+  let serial = 0, active = 0, navigating = 0, disposed = false, scheduled = false;
+  const connection = win?.navigator?.connection;
+  const priorityOf = value => value === 'viewport' ? 0 : INTENT;
+  function policy(priority) {
+    const network = win?.navigator?.connection;
+    if (doc?.visibilityState === 'hidden' || win?.navigator?.onLine === false || network?.saveData || /^(slow-)?2g$/.test(network?.effectiveType || '')) return 0;
+    const slow = network?.effectiveType === '3g' || (network?.downlink > 0 && network.downlink < 1.5);
+    return slow ? (priority < INTENT ? 0 : 1) : concurrency;
+  }
+  function finish(task, error, value) {
+    if (!tasks.delete(task)) return;
+    if (task.running) active--;
+    task.abort.signal.removeEventListener('abort', task.cancelled);
+    const { resolve, reject } = task;
+    task.run = task.resolve = task.reject = task.cancelled = undefined;
+    error ? reject(error) : resolve(value);
+    wake();
+  }
+  function start(task) {
+    task.running = true; active++;
+    let result;
+    try { result = task.run(task.abort.signal); } catch (error) { finish(task, error); return; }
+    Promise.resolve(result).then(value => finish(task, null, value), error => finish(task, error));
+  }
+  function pump() {
+    scheduled = false;
+    if (disposed) return;
+    const queued = [...tasks].filter(task => !task.running).sort((a, b) => b.priority - a.priority || a.order - b.order);
+    for (const task of queued) {
+      if (!tasks.has(task)) continue;
+      if (task.priority === 2) { start(task); continue; }
+      if (navigating) break;
+      const slots = policy(task.priority);
+      if (!slots) { task.abort.abort(abortError()); continue; }
+      if (active >= slots) continue;
+      start(task);
+    }
+  }
+  function wake() {
+    if (scheduled || disposed) return;
+    scheduled = true; queueMicrotask(pump);
+  }
+  function changed() {
+    for (const task of tasks) if (task.priority !== 2 && !policy(task.priority)) task.abort.abort(abortError());
+    wake();
+  }
+  doc?.addEventListener?.('visibilitychange', changed);
+  win?.addEventListener?.('online', changed);
+  win?.addEventListener?.('offline', changed);
+  connection?.addEventListener?.('change', changed);
+  return {
+    schedule(run, { priority, abort = new AbortController() } = {}) {
+      const rank = priorityOf(priority);
+      if (disposed || abort.signal.aborted || !policy(rank)) return undefined;
+      if (tasks.size >= limit) {
+        // Keep intent ahead of broad viewport scans. Never evict demand work.
+        const oldest = [...tasks].filter(task => task.priority < 2).sort((a, b) => a.priority - b.priority || a.order - b.order)[0];
+        if (!oldest || oldest.priority > rank) return undefined;
+        oldest.abort.abort(abortError());
+      }
+      const task = { run, abort, priority: rank, order: serial++ };
+      const promise = new Promise((resolve, reject) => { task.resolve = resolve; task.reject = reject; });
+      // Cancellation also settles a task whose producer ignores AbortSignal.
+      // A late result cannot regain a queue slot or resurrect an invalid cache.
+      task.cancelled = () => finish(task, abort.signal.reason || abortError());
+      tasks.add(task); abort.signal.addEventListener('abort', task.cancelled, { once: true });
+      wake();
+      return { abort, promise,
+        promote(priority = 'intent') { if (tasks.has(task)) { task.priority = Math.max(task.priority, priorityOf(priority)); wake(); } },
+        demand() { if (tasks.has(task)) { task.priority = 2; wake(); } },
+      };
+    },
+    navigation(target) {
+      navigating++;
+      target?.demand();
+      for (const task of tasks) if (task.abort !== target?.abort && task.priority !== 2) task.abort.abort(abortError());
+      let released = false;
+      return () => { if (!released) { released = true; navigating--; wake(); } };
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      doc?.removeEventListener?.('visibilitychange', changed);
+      win?.removeEventListener?.('online', changed);
+      win?.removeEventListener?.('offline', changed);
+      connection?.removeEventListener?.('change', changed);
+      for (const task of tasks) task.abort.abort(abortError());
+    },
+  };
+}

package/runtime/profile.mjs

@@ -1,9 +1,23 @@
 import presets from './profiles.json' with { type: 'json' };
 
+export function rscResourceLimits(environment=process.env,production=environment.NODE_ENV!=='development'){
+  if(!production||/--max[-_]semi[-_]space[-_]size(?:[=\s]|$)/.test(environment.NODE_OPTIONS||''))return undefined;
+  return {maxYoungGenerationSizeMb:runtimeProfile(environment,production).youngGenerationMiB};
+}
+
 export function runtimeProfile(environment = process.env, production = environment.NODE_ENV !== 'development') {
   const requested = environment.PRNEXT_PROFILE || (environment.PRNEXT_MEMORY_PROFILE === 'compact' ? 'compact' : 'balanced');
   const name = requested === 'standard' ? 'classic' : requested;
   if (!Object.hasOwn(presets, name)) throw new Error(`Unknown runtime profile ${JSON.stringify(name)}; use ${Object.keys(presets).join(', ')}`);
   const effective = production ? name : 'classic';
+  if(production&&environment.PRNEXT_EFFECTIVE_PROFILE){
+    let value;
+    try{value=JSON.parse(environment.PRNEXT_EFFECTIVE_PROFILE);}catch{throw new Error('Invalid effective runtime profile');}
+    const settings=value?.[1],original=presets[effective];
+    if(!Array.isArray(value)||value.length!==2||value[0]!==effective||!settings||
+      Object.keys(settings).length!==Object.keys(original).length||Object.keys(original).some(key=>!Object.hasOwn(settings,key)||
+        (original[key]===null?settings[key]!==null&&(!Number.isSafeInteger(settings[key])||settings[key]<1):typeof original[key]==='boolean'?typeof settings[key]!=='boolean':!Number.isSafeInteger(settings[key])||settings[key]<1||settings[key]>Math.max(512,original[key]))))throw new Error('Invalid effective runtime profile');
+    return {name:effective,...settings};
+  }
   return { name: effective, ...presets[effective] };
 }

package/runtime/profiles.json

@@ -40,9 +40,9 @@
     "renderIdleSeconds": null
   },
   "memory": {
-    "optimizeForSize": true,
+    "optimizeForSize": false,
     "semiSpaceMiB": 2,
-    "youngGenerationMiB": 4,
+    "youngGenerationMiB": 8,
     "renderStarts": 8,
     "liveResponses": 28,
     "apiConcurrency": 64,

package/runtime/render.mjs

@@ -1,3 +1,4 @@
+import {reportRequestError} from './instrumentation.mjs';
 import { localePath } from '../compat/locale.cjs';
 import React from 'react';
 import DefaultApp, { loadGetInitialProps } from '../compat/app.cjs';
@@ -94,6 +95,7 @@ export async function renderPageRequest(options) {
   try { result = await renderPage({ ...options, capturedResponse }); }
   catch (error) {
     if ([400, 504].includes(error?.statusCode) || options.signal?.aborted) throw error;
+    reportRequestError(error);
     console.error('[prnext]', error?.stack || error);
     return renderPageError(options, { statusCode: 500, error, responseHeaders: capturedResponse.getHeaders() });
   }
@@ -266,6 +268,7 @@ export async function renderIsrPage(options) {
   catch (error) {
     if (!options.capturePageFailure) throw error;
     const pageFailure = summarizePageFailure(error);
+    reportRequestError(error);
     console.error('[prnext] Page generation failed:', pageFailure.stack || pageFailure.message);
     return { status: 500, headers: {}, body: Buffer.alloc(0), pageFailure };
   }

package/runtime/route-pattern.mjs

@@ -0,0 +1,44 @@
+/** Shared browser route matching; importing this never loads either router. */
+export function matchPagePattern(pattern, pathname) {
+  let segments;
+  try { segments = pathname.replace(/\/+$/, '').split('/').slice(1).map(decodeURIComponent); }
+  catch { return null; }
+  if (segments.length === 1 && !segments[0]) segments = [];
+  if (segments.some(segment => !segment || /[/\\\0]/.test(segment) || segment === '.' || segment === '..')) return null;
+  const parts = pattern === '/' ? [] : pattern.split('/').slice(1), params = Object.create(null), rank = [];
+  let index = 0;
+  for (const part of parts) {
+    const optional = /^\[\[\.\.\.([^\]]+)\]\]$/.exec(part);
+    const catchall = /^\[\.\.\.([^\]]+)\]$/.exec(part);
+    const parameter = /^\[([^\]]+)\]$/.exec(part);
+    if (optional || catchall) {
+      if (catchall && index === segments.length) return null;
+      if (index !== segments.length) params[(optional || catchall)[1]] = segments.slice(index);
+      index = segments.length; rank.push(optional ? 0 : 1);
+    } else if (parameter) {
+      if (index === segments.length) return null;
+      params[parameter[1]] = segments[index++]; rank.push(2);
+    } else {
+      if (segments[index++] !== part) return null;
+      rank.push(3);
+    }
+  }
+  return index === segments.length ? { params, rank } : null;
+}
+
+export function isHtmlDocumentRoute(routes, pathname) {
+  let winner;
+  for (const route of routes || []) {
+    const match = matchPagePattern(route.pattern, pathname);
+    if (!match) continue;
+    const rank = winner && (() => {
+      for (let index = 0; index < Math.max(match.rank.length, winner.rank.length); index++) {
+        const difference = (match.rank[index] ?? 4) - (winner.rank[index] ?? 4);
+        if (difference) return difference;
+      }
+      return 0;
+    })();
+    if (!winner || rank > 0) winner = { ...match, route };
+  }
+  return winner?.route.htmlOnly === true;
+}

package/runtime/rsc-worker.mjs

@@ -1,3 +1,5 @@
+import {drainTraces} from './trace.mjs';
+import {withInstrumentation,reportRequestError,wasRequestErrorReported} from './instrumentation.mjs';
 import React from 'react';
 import {scheduleCompileCacheFlush} from './compile-cache.mjs';
 import {preloadModules} from './preload.mjs';
@@ -8,6 +10,7 @@ import { createFromReadableStream } from 'react-server-dom-webpack/client.edge';
 import { parentPort } from 'node:worker_threads';
 import { pathToFileURL } from 'node:url';
 import { createHash } from 'node:crypto';
+import { navigationAuthorization } from '../compat/navigation-authorization.cjs';
 import { runRequestContext, currentRequest } from '../compat/headers.cjs';
 import { Metadata } from './app-metadata.mjs';
 import { appTimeoutError } from './app-errors.mjs';
@@ -27,6 +30,8 @@ import { flightConsumer } from './cache-components-rsc.mjs';
 import { partialModel, isPartialHole, boundedPartialFlight } from './app-partial-model.mjs';
 import { PartialTemplates, canResumePartialDirectly, partialTemplateReuse } from './partial-template.mjs';
 import { createAfterScope } from '../compat/after.cjs';
+import {renderKeyFor} from './app-render-key.mjs';
+import { selectAppStyles } from './app-style-selection.mjs';
 
 installFetchCache();
 if (process.env.PRNEXT_INSPECT_DIR) parentPort.postMessage({type:'rsc-ready'});
@@ -71,6 +76,9 @@ function queryObject(url) {
 }
 
 function createTree(entry, request, fallback = null) {
+  function RetainedBranch(props) {
+    return React.createElement(entry.ActivitySlot, { ...props, authorizationKey: navigationAuthorization(currentRequest(), request.authorizationSecret || request.actionKey, request.navigationCache?.authCookies) });
+  }
   const params = staticParams(request.params || {});
   const searchParams = staticSearchParams(queryObject(new URL(request.url)), currentRequest(), entry.page?.default?.$$typeof === Symbol.for('react.client.reference'));
   if (entry.routing && !fallback) return createAdvancedTree(entry, request, searchParams);
@@ -100,7 +108,7 @@ function createTree(entry, request, fallback = null) {
   const scopedParams = paramsBySegment(segments, request.params || {});
   for (const segment of segments) {
     scopes.set(segment, `${segment.path || ''}:${JSON.stringify(scopedParams.get(segment))}`);
-    if (request.partialParams?.length) for (const prefix of ['', 'error:', 'navigation:', 'layout:']) keyScope(`${prefix}${segment.path || ''}:`, scopedParams.get(segment), prefix === 'layout:' ? ['segments'] : undefined);
+    if (request.partialParams?.length) for (const prefix of ['', 'error:', 'navigation:', 'layout:', 'activity:']) keyScope(`${prefix}${segment.path || ''}:`, scopedParams.get(segment), prefix === 'layout:' ? ['segments'] : prefix === 'activity:' ? ['identity', 'authorizationKey'] : ['error:', 'navigation:'].includes(prefix) ? ['resetKey'] : undefined);
   }
   let instantConfig = request.instantValidation ? entry.pageConfig?.instant : undefined;
   for (let index = fallback ? Math.min(fallback.index, segments.length - 1) : segments.length - 1; index >= 0; index--) {
@@ -128,6 +136,10 @@ function createTree(entry, request, fallback = null) {
       tree = React.createElement(component(segment.template, 'template'), { key: child ? scopes.get(child) : pageKey }, tree);
     }
     if (segment.layout) {
+      if (entry.ActivitySlot) tree = React.createElement(RetainedBranch, {
+        identity: segments.slice(index + 1).some(child => child.layout) ? scopes.get(segments[index + 1]) : pageKey + new URL(request.originalUrl || request.url).search,
+        key: `activity:${scopes.get(segment)}`,
+      }, tree);
       if (request.cacheComponents && segment === rootLayout) tree = React.createElement(React.Fragment, null, head, tree);
       tree = React.createElement(component(segment.layout, 'layout'), { params: staticParams(scopedParams.get(segment)), key: scopes.get(segment) }, tree);
       if (entry.LayoutProvider) tree = React.createElement(entry.LayoutProvider, { key: `layout:${scopes.get(segment)}`,
@@ -196,8 +208,9 @@ async function renderFlight(request, fallback = null, channel = null) {
       try {
         if (request.routingContexts?.size) request.renderRoutingBranch = routingBranchRenderer(cacheContext, bundlerConfig,
           renderSignal, error => publicError(error, request.production).digest);
-        let model = request.controlModel || { ...(allowedRouting ? createTree(entry, request, fallback) : { tree: null, routingInvalid: true }), router, css: request.css || [], fonts: request.fonts || [], ...(request.instantDiagnostics?.length ? { instantDiagnostics: request.instantDiagnostics } : {}), ...request.actionModel };
+        let model = request.controlModel || { ...(allowedRouting ? createTree(entry, request, fallback) : { tree: null, routingInvalid: true }), router, styleRoute: request.routePattern, css: request.css || [], ...(request.cssScopes?.length ? { cssScopes: request.cssScopes } : {}), fonts: request.fonts || [], ...(request.instantDiagnostics?.length ? { instantDiagnostics: request.instantDiagnostics } : {}), ...request.actionModel };
         if (model.routing?.params) model.router.params = model.routing.params;
+        selectAppStyles(model);
         if (request.partialFlight) {
           const consumer = { serverConsumerManifest: flightConsumer(request), replayConsoleLogs: false };
           const decode = () => {
@@ -214,14 +227,16 @@ async function renderFlight(request, fallback = null, channel = null) {
           const keyMap = request.partialKeys ? new Map(request.partialKeys) : undefined;
           model = partialModel(stored, { live, keyMap, reuse: partialTemplateReuse(stored, keyMap) });
         }
+        model.authorizationKey = navigationAuthorization(cacheContext, request.authorizationSecret || request.actionKey, request.navigationCache?.authCookies);
         const stream = renderToReadableStream(model, bundlerConfig, {
           signal: renderSignal,
           temporaryReferences: request.temporaryReferences,
           onError(error) {
             const failure = error && typeof error === 'object' ? error : new Error(String(error));
-            if (cacheContext.staticState?.partial && isPartialHole(failure)) return 'PRNEXT_PPR_DYNAMIC';
+            if ((cacheContext.staticState?.partial || request.navigationStage) && isPartialHole(failure)) return 'PRNEXT_PPR_DYNAMIC';
             renderError ??= failure;
             const digest = publicError(failure, request.production).digest;
+            if(ordinaryRenderError(failure)&&!abort.signal.aborted&&!channel?.signal.aborted){if(!failure.digest&&Object.isExtensible(failure))failure.digest=digest;const reporting=reportRequestError(failure);if(reporting&&digest.length<=1024&&request.instrumentationId!==undefined)parentPort.postMessage({id:request.instrumentationId,type:'instrumentation-error',value:digest});}
             if (!abort.signal.aborted && !channel?.signal.aborted && ordinaryRenderError(failure)) console.error(`[prnext] ${digest}`, failure?.stack || failure);
             return digest;
           },
@@ -342,7 +357,12 @@ async function renderFlight(request, fallback = null, channel = null) {
   });
 }
 
-async function handleRequest(request, channel = null) {
+async function handleRequest(request,channel=null){
+  process.env.NEXT_RUNTIME='nodejs';
+  if(!request.runtimeInstrumentation&&(request.operation==='static-params'||request.staticGeneration||request.staticState))return handleRequestInner(request,channel);
+  return withInstrumentation({...request,signal:channel?.signal,manifest:{instrumentation:request.instrumentation},route:{router:'app',kind:'page',pattern:request.routePattern,cacheConfig:request.cacheConfig}},()=>handleRequestInner(request,channel),{realm:'rsc'});
+}
+async function handleRequestInner(request, channel = null) {
   if (request.operation === 'static-params') {
     return runRequestContext({ ...request, phase: 'render' }, async () => {
       const context = currentRequest();
@@ -390,6 +410,7 @@ const responseCompletions = new Map();
 const manifests = new Map();
 const artifacts = new Map();
 parentPort.on('message', async ({ id, request, type, value, token }) => {
+  if(type==='telemetry-flush'){await drainTraces();parentPort.postMessage({type:'telemetry-flushed',token});return;}
   if(type==='preload'){
     try{await preloadModules(value.files,value.options,file=>routeEntry({modulePath:file,production:true}));parentPort.postMessage({type:'preloaded',id});}
     catch(error){parentPort.postMessage({type:'preloaded',id,error:error.message});}return;
@@ -410,17 +431,18 @@ parentPort.on('message', async ({ id, request, type, value, token }) => {
   for (const field of ['clientModules', 'actions']) {
     if (request[field + 'Id'] !== undefined) request[field] = manifests.get(request[field + 'Id']);
   }
+  request.instrumentationId=id;
   const channel = request.stream && (!request.action || request.action.id) ? workerStreamChannel(parentPort, id) : null;
   let responseDone, responseTimer;
-  if (request.action && request.cacheConfig?.runtime !== 'edge') {
+  if (request.cacheConfig?.runtime !== 'edge') {
     const timeoutMs = request.renderTimeoutMs ?? 25000;
-    request.afterScope = createAfterScope({ timeoutMs, onComplete: flushCacheWork,
-      onTimeout: error => parentPort.postMessage({ id, error: { message: error.message, retireWorker: true } }) });
-    if (request.waitForResponse) responseDone = new Promise(resolve => {
+    request.afterScope = createAfterScope({report:error=>{console.error('[prnext] after() failed:',error?.stack||error);return reportRequestError(error);}, timeoutMs, onComplete: flushCacheWork,
+      onTimeout: error => parentPort.postMessage({ id, error: { message: error.message, retireWorker: true } }),
+      onRegistered() { if (request.waitForResponse) responseDone = new Promise(resolve => {
       const finish = () => { clearTimeout(responseTimer); resolve(); };
       responseCompletions.set(id, finish);
       responseTimer = setTimeout(finish, timeoutMs);
-    });
+    }); } });
   }
   activeRequests.add(id);
   if (channel) streamChannels.set(id, channel);
@@ -432,14 +454,14 @@ parentPort.on('message', async ({ id, request, type, value, token }) => {
       delete request.partialFlightId;
     }
     if (channel) {
-      await handleRequest({ ...request, renderKey: id }, channel);
+      await handleRequest({ ...request, renderKey: renderKeyFor(request, id) }, channel);
       return;
     }
-    const result = await handleRequest({ ...request, renderKey: id });
+    const result = await handleRequest({ ...request, renderKey: renderKeyFor(request, id) });
     parentPort.postMessage({ id, ...result }, result.body instanceof ArrayBuffer ? [result.body] : []);
   } catch (error) {
     parentPort.postMessage({ id, error: {
-      message: error?.message || String(error), stack: error?.stack, digest: error?.digest, statusCode: error?.statusCode,
+      instrumentationReported:wasRequestErrorReported(error), message: error?.message || String(error), stack: error?.stack, digest: error?.digest, statusCode: error?.statusCode,
       retireWorker: error?.retireWorker, responseHeaders: error?.responseHeaders,
       code: error?.code, staticMode: error?.staticMode, dynamicReason: error?.dynamicReason,
     } });

package/runtime/trace.mjs

@@ -0,0 +1,78 @@
+import {isControlError} from './navigation.mjs';
+import {AsyncLocalStorage} from 'node:async_hooks';
+import {randomBytes} from 'node:crypto';
+import {createRequire} from 'node:module';
+const scope=new AsyncLocalStorage(),rawFetch=globalThis.fetch;
+let api;
+try{api=createRequire(import.meta.url)('@opentelemetry/api');}catch{}
+const endpoint=process.env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT||(process.env.OTEL_EXPORTER_OTLP_ENDPOINT?process.env.OTEL_EXPORTER_OTLP_ENDPOINT.replace(/\/$/,'')+'/v1/traces':undefined);
+const protocol=process.env.OTEL_EXPORTER_OTLP_TRACES_PROTOCOL||process.env.OTEL_EXPORTER_OTLP_PROTOCOL;
+const enabled=process.env.OTEL_SDK_DISABLED!=='true'&&endpoint&&(!protocol||protocol==='http/json');
+const queue=[];let timer,flushing;
+const epoch=BigInt(Date.now())*1000000n-process.hrtime.bigint();
+const nanos=()=>String(epoch+process.hrtime.bigint());
+export function parseTraceparent(value){
+  const match=/^00-([a-f0-9]{32})-([a-f0-9]{16})-([a-f0-9]{2})$/.exec(value||'');
+  return match&&!/^0+$/.test(match[1])&&!/^0+$/.test(match[2])?{traceId:match[1],spanId:match[2],traceFlags:parseInt(match[3],16)&1}:undefined;
+}
+export function currentTraceparent(){const value=scope.getStore();return value?`00-${value.traceId}-${value.spanId}-${value.traceFlags?'01':'00'}`:undefined;}
+export function propagatedFetch(input,init){
+  const parent=currentTraceparent();if(!parent)return [input,init];
+  const headers=new Headers(init?.headers??(input instanceof Request?input.headers:undefined));
+  if(!headers.has('traceparent'))headers.set('traceparent',parent);
+  return [input,{...init,headers}];
+}
+function enqueue(span){
+  if(!enabled||!span.flags||queue.length>=1024)return;
+  queue.push(span);if(!timer)timer=setTimeout(()=>{timer=undefined;void flushTraces();},200).unref();
+}
+export async function flushTraces(){
+  if(flushing)return flushing;
+  if(!queue.length)return;
+  const headers={'content-type':'application/json'};
+  for(const part of (process.env.OTEL_EXPORTER_OTLP_TRACES_HEADERS||process.env.OTEL_EXPORTER_OTLP_HEADERS||'').split(',')){
+    const split=part.indexOf('=');if(split>0)try{headers[part.slice(0,split).trim()]=decodeURIComponent(part.slice(split+1).trim());}catch{}
+  }
+  const spans=queue.splice(0,128);
+  flushing=(async()=>{
+    const body=JSON.stringify({resourceSpans:[{resource:{attributes:[{key:'service.name',value:{stringValue:process.env.OTEL_SERVICE_NAME||'prnext'}}]},scopeSpans:[{scope:{name:'prnext.runtime'},spans}]}]});
+    for(let attempt=0;attempt<3;attempt++){
+      let retry=false;
+      try{
+        const response=await rawFetch(endpoint,{method:'POST',redirect:'error',headers,body,signal:AbortSignal.timeout(1000)});
+        retry=[429,502,503,504].includes(response.status);await response.body?.cancel();
+      }catch{retry=true;} // Telemetry failure never changes an application response.
+      if(!retry)break;
+      if(attempt<2)await new Promise(resolve=>setTimeout(resolve,100*2**attempt).unref());
+    }
+  })().finally(()=>{flushing=undefined;if(queue.length&&!timer)timer=setTimeout(()=>{timer=undefined;void flushTraces();},200).unref();});
+  return flushing;
+}
+export async function drainTraces(){
+  const deadline=Date.now()+2500;let timeout;
+  try{
+    await Promise.race([(async()=>{while((flushing||queue.length)&&Date.now()<deadline)await(flushing||flushTraces());})(),new Promise(resolve=>{timeout=setTimeout(resolve,2500);})]);
+  }finally{clearTimeout(timeout);clearTimeout(timer);timer=undefined;}
+}
+export function markTraceError(){const state=scope.getStore();if(state?.span)state.span.status={code:2};state?.sdkSpan?.setStatus({code:2});}
+export async function withTrace(options,name,callback){
+  const parent=scope.getStore()||parseTraceparent(options.traceparent||new Headers(options.headers).get('traceparent'));
+  if(!enabled&&!api&&!parent)return callback();
+  let sdkSpan;
+  if(!enabled&&api){
+    const remote=parent?api.trace.setSpanContext(api.context.active(),{traceId:parent.traceId,spanId:parent.spanId,traceFlags:parent.traceFlags,isRemote:true}):api.context.active();
+    sdkSpan=api.trace.getTracer('prnext.runtime').startSpan(name,{kind:options.kind||1},remote);
+    const context=sdkSpan.spanContext();
+    if(!api.trace.isSpanContextValid(context)){sdkSpan.end();return callback();}
+    const run=()=>scope.run({...context,sdkSpan},callback);
+    try{return await api.context.with(api.trace.setSpan(remote,sdkSpan),run);}catch(error){if(!isControlError(error))sdkSpan.setStatus({code:2});throw error;}finally{sdkSpan.end();}
+  }
+  const span={traceId:parent?.traceId||randomBytes(16).toString('hex'),spanId:randomBytes(8).toString('hex'),parentSpanId:parent?.spanId,
+    flags:parent?.traceFlags??1,name,kind:options.kind||1,startTimeUnixNano:nanos(),attributes:[]};
+  if(options.route?.pattern)span.attributes.push({key:'http.route',value:{stringValue:options.route.pattern}});
+  const state={traceId:span.traceId,spanId:span.spanId,traceFlags:span.flags,span};
+  const run=()=>scope.run(state,async()=>{
+    try{const result=await callback();if(result?.status>=500)span.status={code:2};return result;}catch(error){if(!isControlError(error))span.status={code:2};throw error;}finally{span.endTimeUnixNano=nanos();enqueue(span);}
+  });
+  return api?api.context.with(api.trace.setSpanContext(api.context.active(),{traceId:state.traceId,spanId:state.spanId,traceFlags:state.traceFlags}),run):run();
+}