@thomas.f/prnext 0.1.11-alpha → 0.1.13-alpha

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

@@ -24,8 +24,10 @@ import { installFetchCache } from './fetch-cache.mjs';
 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';
 
 installFetchCache();
+if (process.env.PRNEXT_INSPECT_DIR) parentPort.postMessage({type:'rsc-ready'});
 
 const MAX_RESPONSE_BYTES = 16 * 1024 * 1024;
 const routeEntries = new Map();
@@ -74,7 +76,7 @@ function createTree(entry, request, fallback = null) {
   const pageKey = `${request.routePattern || new URL(request.url).pathname}:${JSON.stringify(request.params || {})}`;
   const keyScopes = [];
   const instantTrees = [];
-  const instantDisabled = [entry.pageConfig, ...segments.map(segment => segment.staticConfig)].some(config => config?.instant && typeof config.instant === 'object' && (config.instant.unstable_disableValidation || (request.production ? config.instant.unstable_disableBuildValidation : config.instant.unstable_disableDevValidation)));
+  const instantDisabled = request.instantValidation && [entry.pageConfig, ...segments.map(segment => segment.staticConfig)].some(config => config?.instant && typeof config.instant === 'object' && (config.instant.unstable_disableValidation || (request.production ? config.instant.unstable_disableBuildValidation : config.instant.unstable_disableDevValidation)));
   function keyScope(prefix, values, liveProps) {
     const key = prefix + JSON.stringify(values);
     keyScopes.push({ key, prefix, names: Object.keys(values), ...(liveProps ? { liveProps } : {}) });
@@ -97,8 +99,9 @@ function createTree(entry, request, fallback = null) {
     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);
   }
-  let instantConfig = entry.pageConfig?.instant;
-  for (const segment of [...(fallback ? segments.slice(0, fallback.index + 1) : segments)].reverse()) {
+  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--) {
+    const segment = segments[index];
     if (segment.loading) tree = React.createElement(React.Suspense, {
       fallback: React.createElement(component(segment.loading, 'loading')),
     }, tree);
@@ -125,7 +128,7 @@ function createTree(entry, request, fallback = null) {
       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)}`,
-        segments: { children: selectedLayoutSegments(segments.slice(segments.indexOf(segment) + 1), request.params) } }, tree);
+        segments: { children: selectedLayoutSegments(segments, request.params, segments.indexOf(segment) + 1) } }, tree);
     }
   }
   // Keep module namespaces out of development owner props: they can contain
@@ -380,24 +383,38 @@ async function handleRequest(request, channel = null) {
 
 const streamChannels = new Map();
 const activeRequests = new Set();
-const cancelledRequests = new Set();
+const responseCompletions = new Map();
 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 }) => {
+  if (type === 'after-response') { responseCompletions.get(id)?.(); return; }
+  // 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']) {
     if (request[field + 'Id'] !== undefined) request[field] = manifests.get(request[field + 'Id']);
   }
   const channel = request.stream && (!request.action || request.action.id) ? workerStreamChannel(parentPort, id) : null;
+  let responseDone, responseTimer;
+  if (request.action && 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 => {
+      const finish = () => { clearTimeout(responseTimer); resolve(); };
+      responseCompletions.set(id, finish);
+      responseTimer = setTimeout(finish, timeoutMs);
+    });
+  }
   activeRequests.add(id);
   if (channel) streamChannels.set(id, channel);
   try {
@@ -420,7 +437,17 @@ parentPort.on('message', async ({ id, request, type, value }) => {
       code: error?.code, staticMode: error?.staticMode, dynamicReason: error?.dynamicReason,
     } });
   } finally {
+    // Flight completion can precede HTML decoding and socket backpressure.
+    // The HTTP worker acknowledges the actual response end/error/disconnect.
+    // Keep the RSC lease until bounded after-response work has settled.
+    if (request.afterScope) {
+      try { await responseDone; await request.afterScope.finish(); }
+      catch (error) { console.error('[prnext] Server Action after() failed:', error?.stack || error); }
+    }
+    clearTimeout(responseTimer); responseCompletions.delete(id);
     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/stream-utils.mjs

@@ -1,3 +1,5 @@
+const immediate = () => new Promise(resolve => setImmediate(resolve));
+
 export const STREAM_CHUNK_BYTES = 64 * 1024;
 
 export function abortError(reason = 'Response body was canceled') {
@@ -48,6 +50,7 @@ export function streamingBody(source, { signal, onCancel, onComplete, timeoutMs
 
   function clean() {
     clearTimeout(timer);
+    timer = undefined;
     signal?.removeEventListener('abort', aborted);
     chunk = undefined;
     if (reader) {
@@ -70,10 +73,14 @@ export function streamingBody(source, { signal, onCancel, onComplete, timeoutMs
   }
 
   function touch() {
-    clearTimeout(timer);
     if (timeoutMs > 0) {
-      timer = setTimeout(() => stop(apiTimeoutError('response idle', timeoutMs), true), timeoutMs);
-      timer.unref?.();
+      // Keep one request-scoped timer: splitting or reading another chunk must
+      // extend the same idle deadline without allocating another async resource.
+      if (timer) timer.refresh();
+      else {
+        timer = setTimeout(() => stop(apiTimeoutError('response idle', timeoutMs), true), timeoutMs);
+        timer.unref?.();
+      }
     }
   }
   function aborted() { stop(signal.reason, true); }
@@ -87,6 +94,7 @@ export function streamingBody(source, { signal, onCancel, onComplete, timeoutMs
       if (stopped) return { done: true, value: undefined };
       if (nextInProgress) throw new Error('Response body reads must be sequential');
       nextInProgress = true;
+      let emptyReads = 0;
       try {
         while (!chunk || offset >= chunk.byteLength) {
           chunk = undefined;
@@ -105,6 +113,17 @@ export function streamingBody(source, { signal, onCancel, onComplete, timeoutMs
           if (!(next.value instanceof Uint8Array)) throw new TypeError('Response body chunks must be Uint8Array values');
           chunk = next.value;
           offset = 0;
+          if (!chunk.byteLength && ++emptyReads === 32) {
+            // Empty, immediately resolved reads produce no writable I/O and
+            // can otherwise starve cancellation, idle timers and other lanes.
+            // They are not progress: keep the original idle deadline running.
+            emptyReads = 0;
+            await immediate();
+            if (stopped) {
+              if (failure) throw failure;
+              return { done: true, value: undefined };
+            }
+          }
         }
         const value = chunk.subarray(offset, Math.min(offset + STREAM_CHUNK_BYTES, chunk.byteLength));
         offset += value.byteLength;

package/runtime/transport.mjs

@@ -1,7 +1,14 @@
+const yieldToEvents = () => new Promise(resolve => setImmediate(resolve));
+
 export const MAX_STREAM_CHUNK = 64 * 1024;
 const MAX_CONTROL_BYTES = 64 * 1024;
+const STREAM_YIELD_CHUNKS = 32;
 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 +16,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 +34,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 +49,92 @@ 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;
+      let chunksSinceYield = 0;
+      const yieldStream = async () => {
+        // A writable callback may settle on nextTick without polling I/O.
+        // Bound ready producer/write chains so other lanes can authenticate,
+        // timers can run and disconnects can abort this producer promptly.
+        chunksSinceYield = 0;
+        await yieldToEvents();
+        signalController?.signal.throwIfAborted();
+      };
+      // 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));
+            if (++chunksSinceYield === STREAM_YIELD_CHUNKS) await yieldStream();
+          }
+        } 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);
+              // Empty iterable chunks also consume work without writing bytes.
+              if (++chunksSinceYield === STREAM_YIELD_CHUNKS) await yieldStream();
+            } else {
+              for (let offset = 0; offset < value.length; offset += MAX_STREAM_CHUNK) {
+                await sendChunk(id, value.subarray(offset, offset + MAX_STREAM_CHUNK));
+                if (++chunksSinceYield === STREAM_YIELD_CHUNKS) await yieldStream();
+              }
+            }
+          }
+        }
       }
       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-metadata.mjs

@@ -1,5 +1,28 @@
 // Only build manifests belong here. Never register headers, models, closures or
 // request contexts. Eviction is ordered on the same MessagePort as requests.
+const immutableClientManifests = new WeakSet();
+
+// Production build metadata comes from JSON and does not change until a new
+// worker loads the next build. Only explicitly sealed maps can skip validation;
+// callers using mutable manifests (including development) keep the old checks.
+export function freezeClientModules(value) {
+  if (!value || typeof value !== 'object') return value;
+  if (immutableClientManifests.has(value)) return value;
+  const entries = Object.getOwnPropertyDescriptors(value);
+  // An accessor may change even on a frozen object. Do not trust such a map.
+  if (!Object.values(entries).every(entry => Object.hasOwn(entry, 'value') &&
+      entry.value && typeof entry.value === 'object' &&
+      typeof Object.getOwnPropertyDescriptor(entry.value, 'ssrModule')?.value === 'string')) return value;
+  for (const entry of Object.values(entries)) Object.freeze(entry.value);
+  Object.freeze(value);
+  immutableClientManifests.add(value);
+  return value;
+}
+
+export function isImmutableClientModules(value) {
+  return immutableClientManifests.has(value);
+}
+
 export function workerMetadata(port, limit = 32) {
   const entries = new Map();
   let sequence = 0;