@thomas.f/prnext 0.1.1-alpha → 0.1.12-alpha

package/runtime/rsc-lifecycle.mjs

@@ -0,0 +1,119 @@
+import { appTimeoutError } from './app-errors.mjs';
+
+// Per-isolate admission includes abandoned requests until the isolate confirms
+// settlement. A burst of cooperative cancellations gets time to acknowledge
+// without immediately terminating unrelated active responses.
+export function createRscLifecycle(retire, {
+  cancellationLimit = 16, maxActive = 512, maxWaiters = 512,
+} = {}) {
+  for (const [name, value] of Object.entries({ cancellationLimit, maxActive, maxWaiters })) {
+    if (!Number.isSafeInteger(value) || value <= 0) throw new TypeError(`${name} must be a positive safe integer`);
+  }
+  if (typeof retire !== 'function') throw new TypeError('retire must be a function');
+  const active = new Set(), waiters = new Set(), retirementWaiters = new Set();
+  let cancelled = 0, closedError, retirement, retired = false, retirementFailed = false, retirementError;
+  const timeoutError = milliseconds => appTimeoutError('RSC admission', milliseconds);
+  const available = () => !closedError && cancelled < cancellationLimit && active.size < maxActive;
+
+  function lease() {
+    const token = { cancelled: false };
+    active.add(token);
+    return {
+      cancel() {
+        if (!active.has(token) || token.cancelled) return;
+        token.cancelled = true;
+        cancelled++;
+        // Pressure closes admission, never shortens an existing request's
+        // deadline. Mutations and cache work may legitimately outlive callers.
+      },
+      release() {
+        if (!active.delete(token)) return;
+        if (token.cancelled) cancelled--;
+        drain();
+      },
+    };
+  }
+
+  function drain() {
+    for (const waiter of waiters) {
+      if (!available()) break;
+      waiter.cleanup();
+      if (waiter.signal?.aborted) waiter.reject(waiter.signal.reason);
+      else if (performance.now() >= waiter.deadline) waiter.reject(timeoutError(waiter.timeoutMs));
+      else waiter.resolve(lease());
+    }
+  }
+
+  function acquire({ signal, timeoutMs = 28000 } = {}) {
+    if (signal?.aborted) return Promise.reject(signal.reason);
+    if (closedError) return Promise.reject(closedError);
+    if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) return Promise.reject(timeoutError(timeoutMs));
+    if (available()) return Promise.resolve(lease());
+    return queue(waiters, signal, timeoutMs);
+  }
+
+  function queue(collection, signal, timeoutMs) {
+    if (waiters.size + retirementWaiters.size >= maxWaiters) {
+      const error = new Error('App Router RSC admission queue is full');
+      error.statusCode = 503;
+      return Promise.reject(error);
+    }
+    return new Promise((resolve, reject) => {
+      let timer;
+      const onAbort = () => { waiter.cleanup(); reject(signal.reason); };
+      const waiter = { signal, timeoutMs, deadline: performance.now() + timeoutMs, resolve, reject,
+        cleanup() { collection.delete(waiter); clearTimeout(timer); signal?.removeEventListener('abort', onAbort); },
+      };
+      collection.add(waiter);
+      signal?.addEventListener('abort', onAbort, { once: true });
+      timer = setTimeout(() => { waiter.cleanup(); reject(timeoutError(timeoutMs)); }, timeoutMs);
+    });
+  }
+
+  function waitForRetirement({ signal, timeoutMs = 28000 } = {}) {
+    if (signal?.aborted) return Promise.reject(signal.reason);
+    if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) return Promise.reject(timeoutError(timeoutMs));
+    if (!retirement) return Promise.reject(new Error('App Router worker is not retiring'));
+    if (retired) return retirementFailed ? Promise.reject(retirementError) : Promise.resolve();
+    return queue(retirementWaiters, signal, timeoutMs);
+  }
+
+  function finishRetirement(error, failed = false) {
+    retired = true;
+    retirementFailed = failed;
+    retirementError = error;
+    for (const waiter of retirementWaiters) {
+      waiter.cleanup();
+      if (waiter.signal?.aborted) waiter.reject(waiter.signal.reason);
+      else if (performance.now() >= waiter.deadline) waiter.reject(timeoutError(waiter.timeoutMs));
+      else if (failed) waiter.reject(error);
+      else waiter.resolve();
+    }
+  }
+
+  function close(error = new Error('App Router worker closed')) {
+    if (closedError) return;
+    closedError = error;
+    for (const waiter of waiters) { waiter.cleanup(); waiter.reject(error); }
+  }
+
+  function terminate(error = new Error('App Router worker retired')) {
+    close(error);
+    // Worker.terminate() adds an exit listener. Share exactly one call/promise
+    // across all request deadlines, cancellation pressure and shutdown paths.
+    if (!retirement) {
+      retirement = Promise.resolve().then(retire);
+      // One observer per isolate, rather than one Promise reaction retained
+      // for every caller that times out/aborts while the isolate is stopping.
+      retirement.then(() => finishRetirement(), error => finishRetirement(error, true));
+    }
+    return retirement;
+  }
+
+  return {
+    acquire, close, terminate, waitForRetirement,
+    get retiring() { return retirement ?? null; },
+    get closed() { return !!closedError; },
+    get stats() { return { active: active.size, cancelled, waiting: waiters.size + retirementWaiters.size, closed: !!closedError }; },
+  };
+}

package/runtime/rsc-work-watchdog.mjs

@@ -0,0 +1,75 @@
+// Response deadlines stop when a response completes. While its cache work is
+// still settling, probe the shared isolate's responsiveness instead of imposing
+// another deadline on legitimate asynchronous work. Fully idle isolates have
+// no watchdog timer.
+export function createRscWorkWatchdog({ probe, retire, intervalMs = 5000, timeoutMs = 30000 } = {}) {
+  if (typeof probe !== 'function' || typeof retire !== 'function') throw new TypeError('probe and retire must be functions');
+  for (const [name, value] of Object.entries({ intervalMs, timeoutMs })) {
+    if (!Number.isSafeInteger(value) || value <= 0) throw new TypeError(`${name} must be a positive safe integer`);
+  }
+  let work = 0, timer, expected, nextToken = 0, closed = false;
+
+  function clear() {
+    clearTimeout(timer);
+    timer = undefined;
+    expected = undefined;
+  }
+
+  function close() {
+    if (closed) return;
+    closed = true;
+    work = 0;
+    clear();
+  }
+
+  function fail(token, error) {
+    if (closed || !work || expected !== token) return;
+    close();
+    // Close first so concurrent timeout/probe failures cannot retire twice.
+    void Promise.resolve().then(() => retire(error)).catch(failure => {
+      console.error('[prnext] RSC work watchdog retirement failed:', failure);
+    });
+  }
+
+  function schedule() {
+    if (closed || !work || timer !== undefined) return;
+    timer = setTimeout(() => {
+      timer = undefined;
+      if (closed || !work) return;
+      const token = ++nextToken;
+      expected = token;
+      // The default exceeds the existing foreground render deadline: a
+      // synchronous foreground render must not lose its established budget.
+      timer = setTimeout(() => fail(token, new Error(`App Router worker did not acknowledge its background-work probe within ${timeoutMs} ms`)), timeoutMs);
+      timer.unref();
+      try {
+        Promise.resolve(probe(token)).catch(error => fail(token, error));
+      } catch (error) { fail(token, error); }
+    }, intervalMs);
+    timer.unref();
+  }
+
+  function add() {
+    if (closed) return () => {};
+    work++;
+    schedule();
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      if (closed) return;
+      if (--work === 0) clear();
+    };
+  }
+
+  function ack(token) {
+    if (closed || !work || expected === undefined || token !== expected) return;
+    clear();
+    schedule();
+  }
+
+  return {
+    add, ack, close,
+    get stats() { return { work, scheduled: timer !== undefined, awaitingAck: expected !== undefined, closed }; },
+  };
+}

package/runtime/rsc-worker.mjs

@@ -26,6 +26,7 @@ import { partialModel, isPartialHole, boundedPartialFlight } from './app-partial
 import { PartialTemplates, canResumePartialDirectly, partialTemplateReuse } from './partial-template.mjs';
 
 installFetchCache();
+if (process.env.PRNEXT_INSPECT_DIR) parentPort.postMessage({type:'rsc-ready'});
 
 const MAX_RESPONSE_BYTES = 16 * 1024 * 1024;
 const routeEntries = new Map();
@@ -380,18 +381,19 @@ async function handleRequest(request, channel = null) {
 
 const streamChannels = new Map();
 const activeRequests = new Set();
-const cancelledRequests = new Set();
 const manifests = new Map();
 const artifacts = new Map();
-parentPort.on('message', async ({ id, request, type, value }) => {
+parentPort.on('message', async ({ id, request, type, value, token }) => {
+  // Only the host arms these probes, while completed responses still have
+  // tracked cache work. There is no timer or heartbeat in an idle RSC isolate.
+  if (type === 'work-probe') { parentPort.postMessage({ type: 'work-responsive', token }); return; }
   if (type === 'metadata') { manifests.set(id, value); return; }
   if (type === 'metadata-drop') { manifests.delete(id); return; }
   if (type === 'artifact') { artifacts.set(id, value); return; }
   if (type === 'artifact-drop') { artifacts.delete(id); return; }
   if (type === 'credit') { streamChannels.get(id)?.credit(); return; }
   if (type === 'cancel') {
-    if (activeRequests.has(id)) cancelledRequests.add(id);
-    else parentPort.postMessage({ id, type: 'settled' });
+    if (!activeRequests.has(id)) parentPort.postMessage({ id, type: 'settled' });
     streamChannels.get(id)?.cancel(); return;
   }
   for (const field of ['clientModules', 'actions']) {
@@ -421,6 +423,8 @@ parentPort.on('message', async ({ id, request, type, value }) => {
     } });
   } finally {
     streamChannels.delete(id); activeRequests.delete(id);
-    if (cancelledRequests.delete(id)) parentPort.postMessage({ id, type: 'settled' });
+    // A streamed terminal frame can precede asynchronous cache writes. Only
+    // this acknowledgement confirms that all request work has actually ended.
+    parentPort.postMessage({ id, type: 'settled' });
   }
 });

package/runtime/transport.mjs

@@ -2,6 +2,10 @@ export const MAX_STREAM_CHUNK = 64 * 1024;
 const MAX_CONTROL_BYTES = 64 * 1024;
 const NO_BODY = new Set([204, 205, 304]);
 
+export class ProtocolWriteError extends Error {
+  constructor(cause) { super('Request transport write failed', { cause }); }
+}
+
 function bytes(value) {
   if (typeof value === 'string') return Buffer.from(value);
   if (value instanceof ArrayBuffer) return Buffer.from(value);
@@ -9,27 +13,12 @@ function bytes(value) {
   throw new TypeError('A response stream must yield bytes');
 }
 
-async function* responseChunks(body) {
-  if (body === null || body === undefined) return;
-  if (typeof body === 'string' || body instanceof ArrayBuffer || ArrayBuffer.isView(body)) {
-    const value = bytes(body);
-    for (let offset = 0; offset < value.length; offset += MAX_STREAM_CHUNK) yield value.subarray(offset, offset + MAX_STREAM_CHUNK);
-    return;
-  }
-  if (typeof body[Symbol.asyncIterator] !== 'function' && typeof body[Symbol.iterator] !== 'function') {
-    throw new TypeError('Invalid response stream');
-  }
-  for await (const item of body) {
-    const value = bytes(item);
-    for (let offset = 0; offset < value.length; offset += MAX_STREAM_CHUNK) yield value.subarray(offset, offset + MAX_STREAM_CHUNK);
-  }
-}
-
 // A resolved write means the pipe has accepted the bytes. Awaiting every frame
 // prevents Node's writable queue from growing with a slow Rust/HTTP consumer.
 export function createProtocolOutput(write, { cork, uncork } = {}) {
   const send = value => new Promise((resolve, reject) => {
-    write(value, error => error ? reject(error) : resolve());
+    try { write(value, error => error ? reject(new ProtocolWriteError(error)) : resolve()); }
+    catch (error) { reject(new ProtocolWriteError(error)); }
   });
   const controlLine = frame => {
     const value = JSON.stringify(frame) + '\n';
@@ -42,11 +31,11 @@ export function createProtocolOutput(write, { cork, uncork } = {}) {
     try {
       for (let index = 0; index < parts.length; index++) {
         write(parts[index], error => {
-          if (error) reject(error);
+          if (error) reject(new ProtocolWriteError(error));
           else if (index === parts.length - 1) resolve();
         });
       }
-    } catch (error) { reject(error); }
+    } catch (error) { reject(new ProtocolWriteError(error)); }
     finally { uncork(); }
   });
   const sendChunk = (id, chunk) => {
@@ -57,48 +46,79 @@ export function createProtocolOutput(write, { cork, uncork } = {}) {
   };
 
   return async function output(id, result, { stream = false, compactResponse = false, method = 'GET', production = true, signalController } = {}) {
-    const responseBody = result.bufferedBody ?? result.body;
-    const pageError = { ...(result.pageError ? { pageError: result.pageError } : {}),
-      ...(result.pageFailure ? { pageFailure: result.pageFailure } : {}) };
-    if (stream && !result.isr && (method === 'HEAD' || NO_BODY.has(result.status))) {
-      await result.cancel?.();
-      if (result.body?.cancel && !result.body.locked) await result.body.cancel();
-      await send(JSON.stringify({ id, status: result.status, headers: result.headers || {}, body: '', ...pageError }) + '\n');
-      return;
-    }
-    if (!stream && !result.isr) {
-      await send(JSON.stringify({ id, status: result.status, headers: result.headers || {}, body: Buffer.from(result.body || '').toString('base64'), ...pageError }) + '\n');
-      return;
-    }
-    const headers = Object.fromEntries(Object.entries(result.headers || {}).filter(([name]) => name.toLowerCase() !== 'content-length'));
-    if (compactResponse && !result.isr && (typeof responseBody === 'string' || responseBody instanceof ArrayBuffer || ArrayBuffer.isView(responseBody))) {
-      const body = bytes(responseBody);
-      if (body.length <= 16 * 1024) {
-        const complete = controlLine({ id, type: 'complete', status: result.status, headers, length: body.length, ...pageError });
-        if (cork && uncork) await sendParts(body.length ? [complete, body] : [complete]);
-        else { await send(complete); if (body.length) await send(body); }
+    let responseStarted = false, bodyCancelled = false;
+    try {
+      signalController?.signal.throwIfAborted();
+      const responseBody = result.bufferedBody ?? result.body;
+      const pageError = { ...(result.pageError ? { pageError: result.pageError } : {}),
+        ...(result.pageFailure ? { pageFailure: result.pageFailure } : {}) };
+      if (stream && !result.isr && (method === 'HEAD' || NO_BODY.has(result.status))) {
+        bodyCancelled = true;
+        await result.cancel?.();
+        if (result.body?.cancel && !result.body.locked) await result.body.cancel();
+        await send(JSON.stringify({ id, status: result.status, headers: result.headers || {}, body: '', ...pageError }) + '\n');
         return;
       }
-    }
-    const head = controlLine({ id, type: 'head', status: result.status, headers, ...pageError, ...(result.isr ? { isr: result.isr } : {}) });
-    if (cork && uncork && (typeof responseBody === 'string' || responseBody instanceof ArrayBuffer || ArrayBuffer.isView(responseBody))) {
-      const body = bytes(responseBody);
-      if (body.length <= MAX_STREAM_CHUNK) {
-        // Pages HTML and buffered action responses already know their entire
-        // small body. Send their frames together, keeping the same wire format.
-        await sendParts([head, ...(body.length ? [controlLine({id,type:'chunk',length:body.length}),body] : []), controlLine({id,type:'end'})]);
+      if (!stream && !result.isr) {
+        await send(JSON.stringify({ id, status: result.status, headers: result.headers || {}, body: Buffer.from(result.body || '').toString('base64'), ...pageError }) + '\n');
         return;
       }
-    }
-    await send(head);
-    try {
-      for await (const chunk of responseChunks(responseBody)) {
-        await sendChunk(id, chunk);
+      const headers = Object.fromEntries(Object.entries(result.headers || {}).filter(([name]) => name.toLowerCase() !== 'content-length'));
+      if (compactResponse && !result.isr && (typeof responseBody === 'string' || responseBody instanceof ArrayBuffer || ArrayBuffer.isView(responseBody))) {
+        const body = bytes(responseBody);
+        if (body.length <= 16 * 1024) {
+          const complete = controlLine({ id, type: 'complete', status: result.status, headers, length: body.length, ...pageError });
+          if (cork && uncork) await sendParts(body.length ? [complete, body] : [complete]);
+          else { await send(complete); if (body.length) await send(body); }
+          return;
+        }
+      }
+      const head = controlLine({ id, type: 'head', status: result.status, headers, ...pageError, ...(result.isr ? { isr: result.isr } : {}) });
+      if (cork && uncork && (typeof responseBody === 'string' || responseBody instanceof ArrayBuffer || ArrayBuffer.isView(responseBody))) {
+        const body = bytes(responseBody);
+        if (body.length <= MAX_STREAM_CHUNK) {
+          // Pages HTML and buffered action responses already know their entire
+          // small body. Send their frames together, keeping the same wire format.
+          await sendParts([head, ...(body.length ? [controlLine({id,type:'chunk',length:body.length}),body] : []), controlLine({id,type:'end'})]);
+          return;
+        }
+      }
+      await send(head);
+      responseStarted = true;
+      // Iterate the producer directly: an intermediate async generator adds
+      // promise reactions and Buffer views for every already bounded chunk.
+      // Each write still settles before the next chunk or producer read.
+      if (responseBody !== null && responseBody !== undefined) {
+        if (typeof responseBody === 'string' || responseBody instanceof ArrayBuffer || ArrayBuffer.isView(responseBody)) {
+          const value = bytes(responseBody);
+          for (let offset = 0; offset < value.length; offset += MAX_STREAM_CHUNK) {
+            await sendChunk(id, value.subarray(offset, offset + MAX_STREAM_CHUNK));
+          }
+        } else {
+          if (typeof responseBody[Symbol.asyncIterator] !== 'function' && typeof responseBody[Symbol.iterator] !== 'function') {
+            throw new TypeError('Invalid response stream');
+          }
+          for await (const item of responseBody) {
+            const value = bytes(item);
+            if (value.length <= MAX_STREAM_CHUNK) {
+              if (value.length) await sendChunk(id, value);
+            } else {
+              for (let offset = 0; offset < value.length; offset += MAX_STREAM_CHUNK) {
+                await sendChunk(id, value.subarray(offset, offset + MAX_STREAM_CHUNK));
+              }
+            }
+          }
+        }
       }
       await control({ id, type: 'end' });
     } catch (error) {
+      const cancelled = signalController?.signal.aborted || error instanceof ProtocolWriteError;
       signalController?.abort(error);
-      await result.cancel?.(error);
+      if (!bodyCancelled) await result.cancel?.(error);
+      // Socket cancellation has no writable peer and no protocol recovery on
+      // this lane. Cancel its producer once; never attempt a second write (and
+      // secondary EPIPE) or report a client disconnect as an application error.
+      if (cancelled || !responseStarted) throw error;
       console.error('[prnext] Response stream failed:', error?.stack || error);
       // Headers are already on the wire: terminate this response, never emit a
       // replacement HTTP response or retry application code after a mutation.

package/runtime/worker.mjs

@@ -12,8 +12,11 @@ import net from 'node:net';
 import { timingSafeEqual } from 'node:crypto';
 import { Console } from 'node:console';
 import { navigationResponse } from './navigation.mjs';
-import { createProtocolOutput } from './transport.mjs';
+import { createProtocolOutput, ProtocolWriteError } from './transport.mjs';
 import { loadEnvConfig } from './env.mjs';
+import diagnostics from '../compat/diagnostics.cjs';
+
+if (diagnostics.enabled) diagnostics.record('wake', { phase: 'node-entry', uptimeMs: process.uptime() * 1000, bootstrapMs: performance.nodeTiming.bootstrapComplete });
 
 // stdout is exclusively the transport, including when user packages log during import.
 const writeProtocol = process.stdout.write.bind(process.stdout);
@@ -34,7 +37,12 @@ process.env.NODE_ENV = manifest.dev ? 'development' : 'production';
 const production = !manifest.dev;
 // Load each renderer beside the application only when that request needs it.
 // Middleware and API workers do not pay for React or the Pages/App renderers.
-const runtimeModule = name => import(pathToFileURL(path.join(distDir, `runtime/${name}.mjs`)).href);
+const runtimeModule = async name => {
+  const started = diagnostics.enabled ? performance.now() : 0;
+  const module = await import(pathToFileURL(path.join(distDir, `runtime/${name}.mjs`)).href);
+  if (diagnostics.enabled) diagnostics.record('wake', { phase: 'module', module: name, durationMs: performance.now() - started });
+  return module;
+};
 let errorResponse;
 try { ({ errorResponse } = await runtimeModule('http')); }
 catch (error) { console.error('PRNext worker could not load the project runtime:', error.message); process.exit(1); }
@@ -48,7 +56,7 @@ let pagesRuntime;
 let apiRuntime;
 let incrementalRuntime;
 
-async function handleRequest(input, output, signalController) {
+async function handleRequest(input, output, signalController, responseComplete) {
   let responseStarted = false;
   try {
     if (input.renderMode === 'incremental-cache' && input.routeId === '__prnext_incremental_cache') {
@@ -78,7 +86,7 @@ async function handleRequest(input, output, signalController) {
         appStaticRuntime ??= await import(pathToFileURL(path.join(distDir, 'runtime/app-static.mjs')).href);
         result = await appStaticRuntime.renderAppIsrPage(options);
       } else {
-        appRuntime ??= await import(pathToFileURL(path.join(distDir, 'runtime/app-render.mjs')).href);
+        appRuntime ??= await runtimeModule('app-render');
         result = await appRuntime.renderAppPage(options);
       }
     } else if (route.router === 'app' && route.kind === 'api' && input.renderMode === 'isr') {
@@ -97,16 +105,23 @@ async function handleRequest(input, output, signalController) {
     input.body = undefined;
     options.body = undefined;
     responseStarted = true;
-    try { await output(input.id, result, { ...input, production, signalController }); }
+    try {
+      await output(input.id, result, { ...input, production, signalController });
+      responseComplete?.();
+    }
     finally { await result.finalizeCache?.(); }
   } catch (error) {
+    const cancelled = signalController.signal.aborted || error instanceof ProtocolWriteError;
     signalController.abort(error);
-    if (responseStarted) {
+    if (responseStarted || cancelled) {
       // A broken pipe or invalid transport cannot be repaired with a second
-      // response on the same request. Rust replaces this failed worker.
+      // response on the same request. Rust discards the incomplete lane.
       throw error;
     }
-    await output(input?.id ?? null, navigationResponse(error) || errorResponse(error, production), { ...input, production, signalController });
+    // The application's scope was aborted above, but the lane is still valid
+    // for its one error/redirect response. Do not mistake that cleanup signal
+    // for a client disconnect while writing the replacement headers.
+    await output(input?.id ?? null, navigationResponse(error) || errorResponse(error, production), { ...input, production });
   }
 }
 
@@ -114,12 +129,22 @@ async function handleRequest(input, output, signalController) {
 // response never blocks another response's bytes or aborts its request context.
 const laneLimit = Math.min(512, Math.max(1, Number(process.env.PRNEXT_WORKER_SOCKET) || 1));
 const token = process.env.PRNEXT_WORKER_TOKEN;
+const reportActivity = process.env.PRNEXT_WORKER_ACTIVITY === '1';
 delete process.env.PRNEXT_WORKER_TOKEN;
 delete process.env.PRNEXT_WORKER_SOCKET;
+delete process.env.PRNEXT_WORKER_ACTIVITY;
 if (token && laneLimit > 1) {
   const expected = Buffer.from(token);
   const sockets = new Set();
   const invocations = new Set();
+  let shuttingDown = false;
+  let reportedBusy = false;
+  const announceActivity = () => {
+    if (!reportActivity || !invocations.size || reportedBusy || shuttingDown) return;
+    reportedBusy = true;
+    writeProtocol('busy\n');
+  };
+  const exitWhenDrained = () => { if (shuttingDown && !invocations.size) process.exit(0); };
   const server = net.createServer(socket => {
     if (sockets.size >= laneLimit) { socket.destroy(); return; }
     sockets.add(socket); socket.setNoDelay(true);
@@ -134,7 +159,6 @@ if (token && laneLimit > 1) {
       const abandoned = controller;
       if (!abandoned || abandoned.signal.aborted) return;
       abandoned.abort(new Error('Request transport closed'));
-
     };
     socket.on('end', disconnected);
     socket.on('close', disconnected);
@@ -149,42 +173,83 @@ if (token && laneLimit > 1) {
           if (invocations.size >= laneLimit) throw new Error('Worker invocation capacity exceeded');
           controller = new AbortController();
           const active = controller;
-          let pendingWork = 0, finished = false;
+          let pendingWork = 0, unsupervisedWork = 0, finished = false;
           invocations.add(active);
-          active.signal[requestWork] = promise => {
+          announceActivity();
+          active.signal[requestWork] = (promise, options) => {
             pendingWork++;
-            const settled = () => { if (--pendingWork === 0 && finished) invocations.delete(active); };
+            // RSC owns both its foreground deadline and its post-response
+            // responsiveness watchdog. Do not apply legacy orphan timeouts to
+            // legitimate cache work merely because its HTTP body has ended.
+            const supervised = options?.supervised === true;
+            if (!supervised) unsupervisedWork++;
+            const settled = () => {
+              pendingWork--;
+              if (!supervised) unsupervisedWork--;
+              if (pendingWork && !unsupervisedWork) clearTimeout(workTimer);
+              if (!pendingWork && finished) {
+                clearTimeout(workTimer);
+                invocations.delete(active); exitWhenDrained();
+              }
+            };
             workScope.runInAsyncScope(() => Promise.resolve(promise).then(settled, settled));
           };
+          let workTimer;
           const retireIfAbandoned = () => {
-            const timer = setTimeout(() => { if (invocations.has(active)) process.exit(70); }, 5000);
-            timer.unref();
+            if (pendingWork && !unsupervisedWork) return;
+            workTimer = setTimeout(() => {
+              if (invocations.has(active) && (!pendingWork || unsupervisedWork)) process.exit(70);
+            }, 5000);
+            workTimer.unref();
           };
           active.signal.addEventListener('abort', retireIfAbandoned, { once: true });
-          try { await handleRequest(input, output, active); }
+          try { await handleRequest(input, output, active, () => { controller = undefined; }); }
           finally {
             finished = true;
-            if (!pendingWork) invocations.delete(active);
-            else if (!active.signal.aborted) {
-              // Background code after sending a complete response still has a
-              // finite lifetime, matching the native request deadline.
-              const timer = setTimeout(() => { if (invocations.has(active)) process.exit(70); }, 30000);
-              timer.unref();
+            if (!pendingWork) { invocations.delete(active); clearTimeout(workTimer); }
+            else {
+              if (unsupervisedWork && !active.signal.aborted) {
+                workTimer = setTimeout(() => { if (invocations.has(active) && unsupervisedWork) process.exit(70); }, 30000);
+                workTimer.unref();
+              }
             }
             controller = undefined;
+            exitWhenDrained();
           }
         }
       } catch (error) {
-        if (!socket.destroyed) console.error('[prnext] Request lane failed:', error?.message || error);
+        if (!socket.destroyed && !socket.readableEnded && !(error instanceof ProtocolWriteError)) console.error('[prnext] Request lane failed:', error?.message || error);
       } finally { socket.destroy(); }
     })();
   });
   // The stdin pipe is a parent-lifetime guard even though requests use sockets.
+  let heartbeat;
+  const shutdown = () => {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    clearInterval(heartbeat);
+    for (const socket of sockets) socket.destroy();
+    server.close();
+    exitWhenDrained();
+  };
   process.stdin.resume();
-  process.stdin.once('end', () => { for (const socket of sockets) socket.destroy(); server.close(); process.exit(0); });
+  process.stdin.once('end', shutdown);
+  // The native pool can close its control reader before Node observes stdin
+  // EOF. Treat that broken parent pipe as the same graceful shutdown; ordinary
+  // stdout failures remain fatal instead of silently losing protocol errors.
+  process.stdout.on('error', error => {
+    if (error.code === 'EPIPE') shutdown();
+    else throw error;
+  });
   server.listen(0, '127.0.0.1', () => {
-    writeProtocol(JSON.stringify({ port: server.address().port, binary: true, heartbeat: true }) + '\n');
-    setInterval(() => writeProtocol('alive\n'), 1000).unref();
+    writeProtocol(JSON.stringify({ port: server.address().port, binary: true, heartbeat: true, activity: reportActivity, gracefulShutdown: true }) + '\n');
+    heartbeat = setInterval(() => {
+      // Coalesce the idle transition with the existing heartbeat. Normal
+      // request completion adds no stdout messages, and short cache bursts
+      // cannot add two messages for every response.
+      reportedBusy = reportActivity && invocations.size > 0;
+      writeProtocol(reportedBusy ? 'busy\n' : 'alive\n');
+    }, 1000).unref();
   });
 } else {
   const output = createProtocolOutput(writeProtocol, { cork: () => process.stdout.cork(), uncork: () => process.stdout.uncork() });