@thomas.f/prnext 0.1.11-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

@@ -0,0 +1,136 @@
+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.
+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;
+  return {
+    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;
+      while (cursor < pending.length) {
+        const start = pending.indexOf('<', cursor);
+        if (start < 0) { cursor = pending.length; break; }
+        cursor = start;
+        let end = -1;
+        if (pending.startsWith('<!--', start)) {
+          const comment = pending.indexOf('-->', start);
+          if (comment >= 0) end = comment + 2;
+        } else {
+          for (let index = start + 1; index < pending.length; index++) {
+            const char = pending[index];
+            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;
+        // Most tags need no special handling. Reject their ASCII prefixes
+        // before running the raw-element and document-closing expressions;
+        // the expressions still validate every candidate in full.
+        const first = pending.charCodeAt(start + 1) | 32;
+        const second = pending.charCodeAt(start + 2) | 32;
+        const rawCandidate = first === 115 && (second === 99 || second === 116 || second === 118) ||
+          first === 116 && (second === 101 || second === 105) || first === 109 && second === 97;
+        rawStart.lastIndex = start;
+        const raw = rawCandidate && rawStart.exec(pending);
+        if (raw && pending[end - 1] !== '/') {
+          const name = raw[1].toLowerCase();
+          let pattern = rawEnds.get(name);
+          if (!pattern) { pattern = new RegExp(`</${name}\\s*>`, 'ig'); rawEnds.set(name, pattern); }
+          pattern.lastIndex = end + 1;
+          const match = pattern.exec(pending);
+          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;
+          if (first === 47 && (second === 98 || second === 104) && documentEnd.test(pending) && documentEnd.lastIndex === end + 1) {
+            ready += pending.slice(output, start);
+            closing += pending.slice(start, end + 1);
+            output = end + 1;
+          }
+          cursor = end + 1;
+        }
+      }
+      ready += pending.slice(output, cursor);
+      pending = pending.slice(cursor);
+      return ready;
+    },
+    finish() {
+      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;
   }
@@ -184,7 +187,7 @@ export function plainResponse(status, message) {
 
 export function errorResponse(error, production = process.env.NODE_ENV === 'production') {
   console.error('[prnext]', error?.stack || error);
-  const status = [400, 504].includes(error?.statusCode) ? error.statusCode : 500;
-  const message = status === 400 ? 'Bad Request' : status === 504 ? 'Gateway Timeout' : 'Internal Server Error';
+  const status = [400, 503, 504].includes(error?.statusCode) ? error.statusCode : 500;
+  const message = status === 400 ? 'Bad Request' : status === 503 ? 'Service Unavailable' : status === 504 ? 'Gateway Timeout' : 'Internal Server Error';
   return plainResponse(status, production || status === 400 ? message : String(error?.stack || error));
 }

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/profiles.json

@@ -6,7 +6,8 @@
     "renderStarts": 16,
     "liveResponses": 32,
     "apiConcurrency": 512,
-    "responseBufferMiB": 8
+    "responseBufferMiB": 8,
+    "renderIdleSeconds": null
   },
   "compact": {
     "optimizeForSize": true,
@@ -15,16 +16,18 @@
     "renderStarts": 16,
     "liveResponses": 32,
     "apiConcurrency": 512,
-    "responseBufferMiB": 8
+    "responseBufferMiB": 8,
+    "renderIdleSeconds": 30
   },
   "balanced": {
-    "optimizeForSize": true,
-    "semiSpaceMiB": 8,
+    "optimizeForSize": false,
+    "semiSpaceMiB": 4,
     "youngGenerationMiB": 16,
     "renderStarts": 16,
     "liveResponses": 32,
     "apiConcurrency": 256,
-    "responseBufferMiB": 4
+    "responseBufferMiB": 4,
+    "renderIdleSeconds": 300
   },
   "speed": {
     "optimizeForSize": false,
@@ -33,15 +36,17 @@
     "renderStarts": 32,
     "liveResponses": 128,
     "apiConcurrency": 512,
-    "responseBufferMiB": 16
+    "responseBufferMiB": 16,
+    "renderIdleSeconds": null
   },
   "memory": {
     "optimizeForSize": true,
     "semiSpaceMiB": 2,
     "youngGenerationMiB": 4,
     "renderStarts": 8,
-    "liveResponses": 16,
+    "liveResponses": 28,
     "apiConcurrency": 64,
-    "responseBufferMiB": 1
+    "responseBufferMiB": 1,
+    "renderIdleSeconds": 30
   }
 }

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/request-work.mjs

@@ -1,7 +1,7 @@
 // Track the actual application promise as well as the HTTP wrapper. A wrapper
 // can reject on abort while npm code keeps running and retaining its context.
 export const requestWork = Symbol.for('prnext.request-work');
-export function trackRequestWork(promise, signal) {
-  signal?.[requestWork]?.(promise);
+export function trackRequestWork(promise, signal, options) {
+  signal?.[requestWork]?.(promise, options);
   return promise;
 }

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-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 }; },
+  };
+}