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

package/runtime/cloud/environment.mjs

@@ -0,0 +1,60 @@
+import { lstat, open } from 'node:fs/promises';
+import path from 'node:path';
+import { createInterface } from 'node:readline/promises';
+import { parse } from 'dotenv';
+import { expand } from 'dotenv-expand';
+
+export const productionEnvFiles = ['.env.production.local', '.env.local', '.env.production', '.env'];
+export async function detectEnvFiles(directory) {
+  const files = [];
+  for (const name of productionEnvFiles) {
+    try { await lstat(path.join(directory, name)); files.push(name); }
+    catch (error) { if (error.code !== 'ENOENT') throw error; }
+  }
+  return files;
+}
+export async function readDeploymentEnv(directory, files) {
+  const values = Object.create(null), combined = Object.create(null);
+  let bytes = 0;
+  for (const name of productionEnvFiles.filter(name => files.includes(name))) {
+    const filename = path.join(directory, name), before = await lstat(filename);
+    if (!before.isFile() || before.isSymbolicLink() || before.size > 65536 || (bytes += before.size) > 65536)
+      throw new Error('Environment files must be regular files, up to 64 KiB in total.');
+    const handle = await open(filename, 'r');
+    let contents;
+    try {
+      const info = await handle.stat();
+      if (info.ino !== before.ino || info.dev !== before.dev || info.size !== before.size || (await lstat(filename)).isSymbolicLink())
+        throw new Error('Environment file changed while reading. Try again.');
+      const data = Buffer.alloc(info.size);
+      let offset = 0;
+      while (offset < data.length) {
+        const {bytesRead} = await handle.read(data,offset,data.length-offset,offset);
+        if (!bytesRead) throw new Error('Environment file changed while reading. Try again.');
+        offset += bytesRead;
+      }
+      contents = data.toString('utf8');
+      const after = await handle.stat();
+      if (after.size !== info.size || after.mtimeMs !== info.mtimeMs) throw new Error('Environment file changed while reading. Try again.');
+    } finally { await handle.close(); }
+    let parsed;
+    // No shell environment: never import machine credentials through expansion.
+    try { parsed = expand({ parsed: parse(contents), processEnv: combined }).parsed; }
+    catch { throw new Error('Could not expand environment variables. Check for circular references.'); }
+    for (const [key, value] of Object.entries(parsed)) if (!Object.hasOwn(values, key)) values[key] = value;
+  }
+  if (Object.keys(values).length > 64 || Buffer.byteLength(JSON.stringify({ variables: values })) > 60000)
+    throw new Error('Environment import exceeds 64 variables or 60 KiB.');
+  for (const [key, value] of Object.entries(values)) {
+    if (!/^[A-Z_][A-Z0-9_]{0,95}$/.test(key) || /^(CLOUD_|DOCKER_|PRNEXT_CACHE_|PRNEXT_BINARY$|PATH$|HOME$|NODE_OPTIONS$|NODE_PATH$|NODE_ENV$|PORT$|HOSTNAME$)/.test(key))
+      throw new Error(`Environment variable ${key.replace(/[^A-Za-z0-9_]/g, '')} is reserved or invalid. Remove it before importing.`);
+    if (value.length > 8192 || value.includes('\0')) throw new Error('An environment value exceeds 8192 characters or contains a null byte.');
+  }
+  return values;
+}
+export async function confirmEnvImport(message, { signal } = {}) {
+  if (!process.stdin.isTTY || !process.stdout.isTTY) return false;
+  const prompt = createInterface({ input: process.stdin, output: process.stdout });
+  try { return /^(y|yes|o|oui)$/i.test((await prompt.question(message + ' [y/N] ', { signal })).trim()); }
+  finally { prompt.close(); }
+}

package/runtime/cloud/state.mjs

@@ -0,0 +1,141 @@
+import { mkdir, lstat, readFile, writeFile, rm, chmod } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import path from 'node:path';
+import { createHash, randomBytes } from 'node:crypto';
+import { rename } from '../fs.mjs';
+
+export function cloudOrigin(value = 'https://app.prnext.dev') {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new Error(
+      'Cloud server must be an HTTPS origin or a loopback HTTP origin.'
+    );
+  }
+  if (
+    url.username ||
+    url.password ||
+    url.pathname !== '/' ||
+    url.search ||
+    url.hash ||
+    !(
+      url.protocol === 'https:' ||
+      (url.protocol === 'http:' &&
+        ['localhost', '127.0.0.1', '[::1]'].includes(url.hostname))
+    )
+  )
+    throw new Error(
+      'Cloud server must be an HTTPS origin or a loopback HTTP origin.'
+    );
+  return url.origin;
+}
+export async function readState(filename) {
+  try {
+    const info = await lstat(filename);
+    if (!info.isFile() || info.isSymbolicLink() || info.size > 65536)
+      throw new Error('Invalid PRNext Cloud state file.');
+    const value = JSON.parse(await readFile(filename, 'utf8'));
+    if (!value || Array.isArray(value) || typeof value !== 'object')
+      throw new Error('Invalid PRNext Cloud state file.');
+    return value;
+  } catch (error) {
+    if (error.code === 'ENOENT') return null;
+    throw error;
+  }
+}
+export async function writeState(filename, data) {
+  const directory = path.dirname(filename);
+  await mkdir(directory, { recursive: true, mode: 0o700 });
+  const info = await lstat(directory);
+  if (info.isSymbolicLink() || !info.isDirectory())
+    throw new Error('PRNext Cloud state directory cannot be a link.');
+  await readState(filename);
+  if (process.platform !== 'win32') await chmod(directory, 0o700);
+  const temporary = `${filename}.${randomBytes(8).toString('hex')}.tmp`;
+  try {
+    await writeFile(temporary, JSON.stringify(data, null, 2) + '\n', {
+      flag: 'wx',
+      mode: 0o600
+    });
+    await rename(temporary, filename);
+  } finally {
+    await rm(temporary, { force: true });
+  }
+}
+export function credentialPath(origin, env = process.env) {
+  const directory = path.resolve(
+    env.PRNEXT_CLOUD_HOME || path.join(homedir(), '.prnext', 'cloud')
+  );
+  return path.join(
+    directory,
+    createHash('sha256').update(cloudOrigin(origin)).digest('hex') + '.json'
+  );
+}
+export const linkPath = (directory) =>
+  path.join(directory, '.prnext-cloud', 'project.json');
+export async function withStateLock(filename, task) {
+  await mkdir(path.dirname(filename), { recursive: true, mode: 0o700 });
+  if ((await lstat(path.dirname(filename))).isSymbolicLink())
+    throw new Error('Cloud state directory cannot be a link.');
+  const marker = { pid: process.pid, nonce: randomBytes(16).toString('hex') };
+  for (let attempt = 0; ; attempt++) {
+    try {
+      await writeFile(filename, JSON.stringify(marker), {
+        flag: 'wx',
+        mode: 0o600
+      });
+      break;
+    } catch (error) {
+      if (error.code !== 'EEXIST') throw error;
+      const previous = await readState(filename);
+      let active = true;
+      if (Number.isSafeInteger(previous?.pid) && previous.pid > 0) {
+        try {
+          process.kill(previous.pid, 0);
+        } catch (failure) {
+          if (failure.code === 'ESRCH') active = false;
+        }
+      }
+      if (active || attempt > 0)
+        throw new Error(
+          'Another PRNext Cloud command is using this project. Wait for it to finish.'
+        );
+      if ((await readState(filename))?.nonce === previous.nonce)
+        await rm(filename);
+    }
+  }
+  try {
+    return await task();
+  } finally {
+    if ((await readState(filename))?.nonce === marker.nonce) await rm(filename);
+  }
+}
+export async function saveLink(directory, link) {
+  await writeState(linkPath(directory), link);
+  const gitignore = path.join(directory, '.gitignore');
+  let contents = '';
+  try {
+    const stat = await lstat(gitignore);
+    if (!stat.isFile() || stat.isSymbolicLink() || stat.size > 65536)
+      throw new Error(
+        'Cannot safely update .gitignore; ignore .prnext-cloud/ manually.'
+      );
+    contents = await readFile(gitignore, 'utf8');
+  } catch (error) {
+    if (error.code !== 'ENOENT') throw error;
+  }
+  if (
+    !contents
+      .split(/\r?\n/)
+      .some((line) =>
+        ['.prnext-cloud/', '/.prnext-cloud/', '.prnext-cloud'].includes(line)
+      )
+  )
+    await writeFile(
+      gitignore,
+      contents +
+        (contents.endsWith('\n') || !contents ? '' : '\n') +
+        '.prnext-cloud/\n'
+    );
+}

package/runtime/cloud/upload.mjs

@@ -0,0 +1,48 @@
+import { open } from 'node:fs/promises';
+import { createHash, randomUUID } from 'node:crypto';
+import { setTimeout as delay } from 'node:timers/promises';
+
+// The checkpoint contains identifiers/checksums only, never source or env contents.
+export async function uploadSource(api, link, archive, {save, signal, log = () => {}}) {
+  const base = `/projects/${encodeURIComponent(link.projectId)}/uploads`;
+  const retry = async fn => {
+    for (let attempt=0;;attempt++) {
+      signal?.throwIfAborted();
+      try { return await fn(); }
+      catch (error) {
+        if (signal?.aborted || attempt >= 3 || error.status && ![408,429,500,502,503,504].includes(error.status) && error.code !== 'upload_busy') throw error;
+        await delay(500 * 2**attempt,undefined,{signal});
+      }
+    }
+  };
+  if (link.upload && link.upload.digest !== archive.digest) {
+    await api(`${base}/${link.upload.id}`,{method:'DELETE'}).catch(error => {if (![404,410].includes(error.status)) throw error;});
+    delete link.upload;
+  }
+  link.upload ||= {id:randomUUID(),digest:archive.digest};
+  await save(link);
+  let session;
+  try {
+    session = await retry(() => api(base,{method:'POST',body:{requestId:link.upload.id,bytes:archive.size,sourceBytes:archive.expandedBytes,digest:archive.digest}}));
+  } catch(error) {
+    if ([404,410].includes(error.status)) {delete link.upload;await save(link);}
+    throw error;
+  }
+  if (session.result) return session.result;
+  if (!Number.isSafeInteger(session.chunkBytes) || session.chunkBytes < 1 || session.chunkBytes > 4*1048576) throw new Error('Unsupported server upload chunk size.');
+  const parts = new Map(session.parts.map(p => [p.part,p.digest]));
+  const handle = await open(archive.path,'r');
+  try {
+    for (let offset=0,part=0;offset<archive.size;offset+=session.chunkBytes,part++) {
+      signal?.throwIfAborted();
+      const body = Buffer.alloc(Math.min(session.chunkBytes,archive.size-offset));
+      let read=0;
+      while (read<body.length) {const result=await handle.read(body,read,body.length-read,offset+read);if(!result.bytesRead)throw new Error('Temporary archive changed. Run the command again.');read+=result.bytesRead;}
+      const digest = createHash('sha256').update(body).digest('hex');
+      if (parts.has(part) && parts.get(part) !== digest) throw new Error('Resumed upload checksum differs. Cancel this upload and try again.');
+      if (!parts.has(part)) await retry(() => api(`${base}/${link.upload.id}/chunks/${part}`,{method:'PUT',body}));
+      log(`Uploading sources: ${Math.round(100*(offset+body.length)/archive.size)}%`);
+    }
+  } finally { await handle.close(); }
+  return retry(() => api(`${base}/${link.upload.id}/complete`,{method:'POST',body:{}}));
+}

package/runtime/html-envelope.mjs

@@ -1,5 +1,50 @@
 import { MAX_RESPONSE_BYTES } from './http.mjs';
 
+// A raw element cannot be interrupted with a Flight script. Keep its chunks
+// until its closing tag arrives, but only scan newly received characters.
+// Joining and rescanning a growing inline script on every chunk is quadratic.
+const whitespace = /\s/;
+function holdRaw(state, text) {
+  if (!text) return;
+  // Compact small chunks in tiers: even single-character input cannot retain
+  // millions of array entries. Each tier joins once per 64 chunks, rather
+  // than repeatedly copying the entire accumulated element.
+  for (let level = 0;; level++) {
+    const parts = state.parts[level] ??= [];
+    parts.push(text);
+    if (parts.length < 64) return;
+    text = parts.join('');
+    parts.length = 0;
+  }
+}
+function releaseRaw(state) {
+  const parts = [];
+  for (let level = state.parts.length - 1; level >= 0; level--) parts.push(...state.parts[level]);
+  return parts.join('');
+}
+function rawEnd(text, state, from = 0) {
+  let index = from;
+  while (index < text.length) {
+    if (!state.matched) {
+      const start = text.indexOf('<', index);
+      if (start < 0) return -1;
+      state.matched = 1;
+      index = start + 1;
+    } else if (state.matched < state.prefix.length) {
+      const code = text.charCodeAt(index);
+      if (state.matched === 1 ? code === 47 : (code | 32) === state.prefix.charCodeAt(state.matched)) {
+        state.matched++;
+        index++;
+      } else state.matched = 0;
+    } else if (text[index] === '>') {
+      return index + 1;
+    } else if (whitespace.test(text[index])) {
+      index++;
+    } else state.matched = 0;
+  }
+  return -1;
+}
+
 // Do not insert Flight/bootstrap scripts inside a split tag or raw-text element.
 // Scan by index: ordinary tags stay in one contiguous slice, instead of creating
 // a new tail and output string for every cell of a rendered table.
@@ -7,6 +52,7 @@ export function htmlEnvelope({ resumed = false } = {}) {
   let pending = '';
   let closing = '';
   let received = 0;
+  let rawPending;
   const rawStart = /<(script|style|textarea|title|svg|math)(?:\s|>)/iy;
   const rawEnds = new Map();
   const documentEnd = /<\/(body|html)\s*>/iy;
@@ -14,8 +60,17 @@ export function htmlEnvelope({ resumed = false } = {}) {
     append(text) {
       received += Buffer.byteLength(text);
       if (received > MAX_RESPONSE_BYTES) throw new Error('HTML response exceeds the 16 MiB PRNext limit');
+      let ready = '';
+      if (rawPending) {
+        const end = rawEnd(text, rawPending);
+        if (end < 0) { holdRaw(rawPending, text); return ''; }
+        holdRaw(rawPending, text.slice(0, end));
+        ready = releaseRaw(rawPending);
+        rawPending = undefined;
+        text = text.slice(end);
+      }
       pending += text;
-      let cursor = 0, output = 0, ready = '';
+      let cursor = 0, output = 0;
       while (cursor < pending.length) {
         const start = pending.indexOf('<', cursor);
         if (start < 0) { cursor = pending.length; break; }
@@ -25,12 +80,13 @@ export function htmlEnvelope({ resumed = false } = {}) {
           const comment = pending.indexOf('-->', start);
           if (comment >= 0) end = comment + 2;
         } else {
-          let quote;
           for (let index = start + 1; index < pending.length; index++) {
             const char = pending[index];
-            if (quote) { if (char === quote) quote = undefined; }
-            else if (char === '"' || char === "'") quote = char;
-            else if (char === '>') { end = index; break; }
+            if (char === '"' || char === "'") {
+              const close = pending.indexOf(char, index + 1);
+              if (close < 0) break;
+              index = close;
+            } else if (char === '>') { end = index; break; }
           }
         }
         if (end < 0) break;
@@ -49,7 +105,14 @@ export function htmlEnvelope({ resumed = false } = {}) {
           if (!pattern) { pattern = new RegExp(`</${name}\\s*>`, 'ig'); rawEnds.set(name, pattern); }
           pattern.lastIndex = end + 1;
           const match = pattern.exec(pending);
-          if (!match) break;
+          if (!match) {
+            rawPending = { prefix: `</${name}`, matched: 0, parts: [] };
+            holdRaw(rawPending, pending.slice(start));
+            rawEnd(pending, rawPending, end + 1);
+            ready += pending.slice(output, start);
+            pending = '';
+            return ready;
+          }
           cursor = pattern.lastIndex;
         } else {
           documentEnd.lastIndex = start;
@@ -66,7 +129,7 @@ export function htmlEnvelope({ resumed = false } = {}) {
       return ready;
     },
     finish() {
-      if (pending || !(resumed ? /^(?:<\/body><\/html>){1,2}$/i : /^<\/body><\/html>$/i).test(closing)) throw new Error('App Router root layout did not close its body and html elements');
+      if (pending || rawPending || !(resumed ? /^(?:<\/body><\/html>){1,2}$/i : /^<\/body><\/html>$/i).test(closing)) throw new Error('App Router root layout did not close its body and html elements');
       return resumed ? '</body></html>' : closing;
     },
   };

package/runtime/http.mjs

@@ -1,4 +1,7 @@
-import { IncomingMessage, validateHeaderName, validateHeaderValue } from 'node:http';
+import { createRequire } from 'node:module';
+// ESM node:http evaluates lazy WebSocket exports and initializes Undici.
+// Use the module object to avoid that startup cost while preserving HTTP patches.
+const http = createRequire(import.meta.url)('node:http');
 import { Duplex, Writable } from 'node:stream';
 import { revalidatePage } from './pages-revalidate.mjs';
 import { currentRequest } from '../compat/headers.cjs';
@@ -45,7 +48,7 @@ export function createRequest({ url, originalUrl, method = 'GET', headers = {},
   const visible = originalUrl ? new URL(originalUrl, parsed) : parsed;
   const socket = new Duplex({ read() {}, write(_chunk, _encoding, callback) { callback(); } });
   socket.remoteAddress = '127.0.0.1';
-  const request = new IncomingMessage(socket);
+  const request = new http.IncomingMessage(socket);
   request.method = method;
   request.url = `${visible.pathname}${visible.search}`;
   request.headers = Object.fromEntries(Object.entries(headers).map(([name, value]) => [name.toLowerCase(), value]));
@@ -85,9 +88,9 @@ export class CapturedResponse extends Writable {
   get finished() { return this.writableEnded; }
   setHeader(name, value) {
     if (this.headersSent) throw new Error('Cannot set headers after they are sent');
-    validateHeaderName(name);
+    http.validateHeaderName(name);
     const normalized = Array.isArray(value) ? value.map(String) : String(value);
-    for (const item of Array.isArray(normalized) ? normalized : [normalized]) validateHeaderValue(name, item);
+    for (const item of Array.isArray(normalized) ? normalized : [normalized]) http.validateHeaderValue(name, item);
     this._headers[name.toLowerCase()] = normalized;
     return this;
   }

package/runtime/middleware.mjs

@@ -12,7 +12,7 @@ installFetchCache();
 
 const FLIGHT_HEADERS = ['rsc', 'next-router-state-tree', 'x-prnext-router-state', 'next-router-prefetch', 'next-hmr-refresh', 'next-router-segment-prefetch'];
 const HOP_HEADERS = new Set(['connection', 'keep-alive', 'proxy-authenticate', 'proxy-authorization', 'te', 'trailer', 'transfer-encoding', 'upgrade', 'content-length']);
-const MAX_BODY = 8 * 1024 * 1024;
+const MAX_BODY = 32 * 1024 * 1024;
 const MAX_SCOPES = 32;
 const MAX_PROMISES = 128;
 const scopes = new Set();
@@ -133,9 +133,9 @@ export async function runMiddleware(options) {
         if (typeof handler !== 'function') throw new TypeError(`Middleware must export a ${exportName} function`);
         const init = { method: options.method || 'GET', headers, signal: controller.signal };
         if (!['GET', 'HEAD'].includes(init.method)) {
-          if (typeof options.body === 'string' && options.body.length > Math.ceil(MAX_BODY / 3) * 4) throw Object.assign(new Error('Middleware request exceeds the 8 MiB PRNext limit'), { statusCode: 413 });
+          if (typeof options.body === 'string' && options.body.length > Math.ceil(MAX_BODY / 3) * 4) throw Object.assign(new Error('Middleware request exceeds the 32 MiB PRNext limit'), { statusCode: 413 });
           const body = Buffer.isBuffer(options.body) ? options.body : Buffer.from(options.body || '', 'base64');
-          if (body.byteLength > MAX_BODY) throw Object.assign(new Error('Middleware request exceeds the 8 MiB PRNext limit'), { statusCode: 413 });
+          if (body.byteLength > MAX_BODY) throw Object.assign(new Error('Middleware request exceeds the 32 MiB PRNext limit'), { statusCode: 413 });
           if (body.byteLength) init.body = body;
         }
         const request = new NextRequest(exposedUrl, { ...init, nextConfig: options.manifest?.config });

package/runtime/request-transport.mjs

@@ -1,5 +1,5 @@
 const MAX_HEADER = 256 * 1024;
-const MAX_BODY = 8 * 1024 * 1024;
+const MAX_BODY = 32 * 1024 * 1024;
 const EMPTY_BODY = Buffer.alloc(0);
 
 // Awaiting the consumer preserves socket backpressure. At most one body is

package/runtime/route-static.mjs

@@ -30,7 +30,7 @@ function canonicalOptions(options) {
 
 function deadline(options, phase) {
   const controller = new AbortController();
-  const timeoutMs = options.timeoutMs ?? 25_000;
+  const timeoutMs = options.timeoutMs ?? (options.route?.cacheConfig?.maxDuration ? options.route.cacheConfig.maxDuration * 1000 : 25_000);
   // Keep the timer alive while awaiting an otherwise handle-free import or
   // generator so Node reports the timeout rather than exiting on pending TLA.
   const timer = setTimeout(() => controller.abort(apiTimeoutError(phase, timeoutMs)), timeoutMs);

package/runtime/rsc-worker.mjs

@@ -24,6 +24,7 @@ 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'});
@@ -75,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 } : {}) });
@@ -98,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);
@@ -126,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
@@ -381,9 +383,11 @@ async function handleRequest(request, channel = null) {
 
 const streamChannels = new Map();
 const activeRequests = new Set();
+const responseCompletions = new Map();
 const manifests = new Map();
 const artifacts = new Map();
 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; }
@@ -400,6 +404,17 @@ parentPort.on('message', async ({ id, request, type, value, token }) => {
     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 {
@@ -422,6 +437,14 @@ parentPort.on('message', async ({ id, request, type, value, token }) => {
       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);
     // A streamed terminal frame can precede asynchronous cache writes. Only
     // this acknowledgement confirms that all request work has actually ended.

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,5 +1,8 @@
+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 {
@@ -85,6 +88,15 @@ export function createProtocolOutput(write, { cork, uncork } = {}) {
       }
       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.
@@ -93,6 +105,7 @@ export function createProtocolOutput(write, { cork, uncork } = {}) {
           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') {
@@ -102,9 +115,12 @@ export function createProtocolOutput(write, { cork, uncork } = {}) {
             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();
               }
             }
           }

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;