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

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();
+}

package/runtime/watch-project.mjs

@@ -23,14 +23,14 @@ export async function watchProject(root, { onChange, onError, ignore = () => fal
         // Rebuilding on those reads restarts the server (and its SSE stream).
         try { if (statSync(path.join(root, relative)).isDirectory()) return; } catch {}
       }
-      onChange(relative);
+      onChange(relative,event);
     });
     watcher.on('error', error => { watcher.close(); onError(error); });
     return { close: () => watcher.close(), async refresh() {} };
   }
   const directories = new Map();
-  const pending = new Set();
-  let closed = false, ready = false, timer, running, refreshAll = false;
+  const pending = new Map();
+  let closed = false, ready = false, timer, running;
   const allowedDirectory = relative => !relative || (!ignore(relative) && (relative === '.contentlayer' || shouldWatchProjectFile(relative)));
   const allowedFile = relative => relative && !ignore(relative) && shouldWatchProjectFile(relative);
   function remove(relative) {
@@ -51,9 +51,9 @@ export async function watchProject(root, { onChange, onError, ignore = () => fal
     close();
     onError(error);
   }
-  function queue(relative) {
+  function queue(relative, recursive = false) {
     if (closed) return;
-    pending.add(relative);
+    pending.set(relative, recursive || pending.get(relative) === true);
     clearTimeout(timer);
     timer = setTimeout(() => { void drain().catch(fail); }, 20);
   }
@@ -84,18 +84,24 @@ export async function watchProject(root, { onChange, onError, ignore = () => fal
           if (process.platform === 'win32' && event === 'change') {
             try { metadataOnly = statSync(path.join(root, changed)).isDirectory(); } catch {}
           }
-          if (allowedFile(changed) && !metadataOnly) onChange(changed);
+          if (allowedFile(changed) && !metadataOnly) onChange(changed,event);
           // The .contentlayer container itself is ignored as a source, but
           // its generated directory may be created after the watcher starts.
-          // Platforms can coalesce a directory rename into a change event.
-          // Rescan only this directory, rather than relying on the event name.
-          if (allowedDirectory(changed) || allowedFile(changed)) queue(relative);
+          // Coalesced notifications can name an already subscribed ancestor,
+          // without a separate event from the changed descendant. Reconcile
+          // that subtree even when its existing directory watches are intact.
+          // Ordinary file edits still scan only their immediate parent.
+          if (!filename) queue(relative, true);
+          else if (allowedDirectory(changed) || allowedFile(changed)) {
+            queue(relative);
+            if (!metadataOnly && directories.has(changed)) queue(changed, true);
+          }
         });
       } catch (error) { if (relative && missing(error)) { disappeared(relative); return; } throw error; }
       directories.set(relative, watcher);
       // Files may already exist by the time a newly created directory is
       // subscribed. Its discovery must also invalidate the source snapshot.
-      if (ready && allowedFile(relative)) onChange(relative);
+      if (ready && allowedFile(relative)) onChange(relative,'rename');
       watcher.on('error', error => {
         if (closed) return;
         if (relative && missing(error)) disappeared(relative);
@@ -109,7 +115,7 @@ export async function watchProject(root, { onChange, onError, ignore = () => fal
     const children = new Set();
     for (const entry of entries) {
       const child = path.posix.join(relative, entry.name);
-      if (fresh && ready && entry.isFile() && allowedFile(child)) onChange(child);
+      if (fresh && ready && entry.isFile() && allowedFile(child)) onChange(child,'rename');
       if (!entry.isDirectory() || !allowedDirectory(child)) continue;
       children.add(child);
       if (recursive || !directories.has(child)) await scan(child, recursive);
@@ -123,8 +129,7 @@ export async function watchProject(root, { onChange, onError, ignore = () => fal
     running = (async () => {
       while (!closed && pending.size) {
         const batch = [...pending]; pending.clear();
-        const recursive = refreshAll; refreshAll = false;
-        for (const relative of batch) await scan(relative, recursive);
+        for (const [relative, recursive] of batch) await scan(relative, recursive);
       }
     })().finally(() => { running = undefined; });
     return running;
@@ -136,8 +141,7 @@ export async function watchProject(root, { onChange, onError, ignore = () => fal
     close,
     async refresh() {
       if (closed) return;
-      refreshAll = true;
-      pending.add('');
+      pending.set('', true);
       await drain();
     },
   };