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

package/runtime/persistent/daemon.mjs

@@ -1,11 +1,12 @@
 import { spawn } from 'node:child_process';
-import { Agent, createServer, request } from 'node:http';
+import { request } from 'node:http';
 import { cp, mkdir, readFile, rm, realpath } from 'node:fs/promises';
 import { randomUUID, createHash } from 'node:crypto';
 import path from 'node:path';
 import { readBuildDirectory } from '../build-directory.mjs';
 import { atomicJSON, delay, environment, validName, validHealthPath } from './common.mjs';
 import { RotatingLog } from './logger.mjs';
+import {nativeGateway,stopNativeProxy} from './native-proxy.mjs';
 
 const home = process.argv[2];
 const registry = path.join(home, 'apps.json');
@@ -16,6 +17,7 @@ const send = message => { if (process.connected) process.send(message); };
 
 function validate(config) {
   validName(config.name); validHealthPath(config.healthPath);
+  if(config.rollbackWindow!==undefined&&(!Number.isInteger(config.rollbackWindow)||config.rollbackWindow<0||config.rollbackWindow>120000))throw new Error('rollbackWindow must be between 0 and 120000 milliseconds');
   if (!path.isAbsolute(config.root) || !path.isAbsolute(config.binary) || !path.isAbsolute(config.node)) throw new Error('Application, Node and native executable paths must be absolute');
   if (!Number.isInteger(config.port) || config.port < 1 || config.port > 65535) throw new Error('--port must be between 1 and 65535');
   if (typeof config.hostname !== 'string' || !config.hostname || /[\s\x00-\x1f]/.test(config.hostname)) throw new Error('Choose a valid --hostname');
@@ -27,7 +29,8 @@ async function persist() {
   await atomicJSON(registry, { version: 1, apps: [...apps.values()].map(app => ({ config: app.config, enabled: app.enabled, snapshots: [...app.snapshots] })) });
 }
 function newApp(config, enabled = false) {
-  return { config, enabled, snapshots: new Set(), active: null, generations: new Set(), gateway: null, sockets: new Set(), state: 'stopped', error: null, starts: 0, failures: [], retry: null,
+  config={rollbackWindow:15000,...config};
+  return { config, enabled, snapshots: new Set(), active: null, generations: new Set(), gateway: null, state: 'stopped', error: null, starts: 0, failures: [], retry: null, probation:null,
     log: new RotatingLog(path.join(home, 'logs', `app-${config.name}.log`)) };
 }
 function summary(app) {
@@ -36,44 +39,13 @@ function summary(app) {
     activeRequests: [...app.generations].reduce((sum, generation) => sum + generation.active, 0),
     draining: [...app.generations].filter(generation => generation !== app.active).length,
     buildId: app.active?.buildId || null, startedAt: app.active?.startedAt || null, error: app.error,
+    proxyPid:app.gateway?.pid||null,
+    rollback:app.probation?{previousBuildId:app.probation.previous.buildId,until:app.probation.deadline}:null,
     log: path.join(home, 'logs', `app-${app.config.name}.log`) };
 }
-function hopHeaders(headers) {
-  const result = { ...headers };
-  const nominated = String(headers.connection || '').split(',').map(value => value.trim().toLowerCase());
-  for (const key of ['connection', 'keep-alive', 'proxy-authenticate', 'proxy-authorization', 'te', 'trailer', 'transfer-encoding', 'upgrade', ...nominated]) delete result[key];
-  return result;
-}
 async function listen(app) {
   if (app.gateway) return;
-  const server = createServer({ requestTimeout: 300000, headersTimeout: 30000 }, (incoming, outgoing) => {
-    const generation = app.active;
-    if (!incoming.url.startsWith('/')) { outgoing.writeHead(400).end('Use a local request path.'); return; }
-    if (!generation || generation.dead) { outgoing.writeHead(503, { 'retry-after': '1' }).end('Application is restarting.'); incoming.resume(); return; }
-    if (generation.active >= 512) { outgoing.writeHead(503, { 'retry-after': '1' }).end('Application is busy.'); incoming.resume(); return; }
-    generation.active++;
-    const headers = hopHeaders(incoming.headers);
-    // Preserve original Host and trusted reverse-proxy headers. Never invent
-    // retry/replay behavior for POSTs or requests that have already streamed.
-    const upstream = request({ host: '127.0.0.1', port: generation.port, method: incoming.method, path: incoming.url, headers, agent: generation.agent }, response => {
-      outgoing.writeHead(response.statusCode, hopHeaders(response.headers));
-      response.on('error', () => outgoing.destroy()); response.pipe(outgoing);
-    });
-    generation.requests.add(upstream);
-    let released = false;
-    const release = () => { if (released) return; released = true; generation.active--; generation.requests.delete(upstream); upstream.destroy(); };
-    outgoing.once('finish', release); outgoing.once('close', release);
-    incoming.once('aborted', () => outgoing.destroy());
-    incoming.once('error', () => outgoing.destroy());
-    upstream.once('error', () => { if (!outgoing.headersSent) outgoing.writeHead(502).end('Application connection closed.'); else outgoing.destroy(); });
-    incoming.pipe(upstream);
-  });
-  server.on('upgrade', (_request, socket) => socket.end('HTTP/1.1 501 Not Implemented\r\nConnection: close\r\nContent-Length: 0\r\n\r\n'));
-  server.on('connection', socket => { app.sockets.add(socket); socket.once('close', () => app.sockets.delete(socket)); });
-  server.maxConnections = 1024;
-  await new Promise((resolve, reject) => { server.once('error', reject); server.listen(app.config.port, app.config.hostname, resolve); });
-  server.on('error', error => { app.error = error.message; app.log.message(error.message); });
-  app.gateway = server;
+  app.gateway=await nativeGateway(app.config,{home,notify:send,onFatal:error=>{console.error(error.message);if(!closing)process.exit(1);}});
 }
 async function removeSnapshot(app, relative) {
   // Only delete a directory generated by this manager inside this exact root.
@@ -120,11 +92,9 @@ async function stopGeneration(app, generation, drain = true) {
   generation.expected = true;
   generation.stopping = (async () => {
     const deadline = Date.now() + (drain ? app.config.drainTimeout : 0);
-    while (generation.active && Date.now() < deadline && !generation.dead) await delay(25);
-    for (const req of generation.requests) req.destroy();
-    generation.agent.destroy();
+    await app.gateway?.retire(generation,drain?Math.max(0,deadline-Date.now()):0).catch(error=>app.log.message(`Proxy retirement: ${error.message}`));
     generation.child.stdin?.end();
-    await Promise.race([generation.closed, delay(3000)]);
+    await Promise.race([generation.closed, delay(drain?Math.max(1000,deadline-Date.now()):3000)]);
     if (!generation.dead) generation.child.kill('SIGKILL');
     if (process.platform !== 'win32' && generation.child.pid) { try { process.kill(-generation.child.pid, 'SIGKILL'); } catch {} }
     await generation.closed;
@@ -156,7 +126,7 @@ async function launch(app) {
     env: { ...environment(), NODE_ENV: 'production', ...(config.inspect ? { PRNEXT_INSPECT_DIR: path.join(config.root, '.prnext-cache/inspect') } : {}) },
   });
   child.stdin.on('error', () => {});
-  const generation = { child, ...build, active: 0, requests: new Set(), agent: new Agent({ keepAlive: true, maxSockets: 512, maxFreeSockets: 16, timeout: 30000 }), dead: false, expected: false, port: null, startedAt: Date.now() };
+  const generation = { child, ...build, active: 0, dead: false, expected: false, port: null, startedAt: Date.now() };
   app.generations.add(generation);
   if (child.pid) send({ type: 'child', pid: child.pid, running: true });
   let output = '', failure;
@@ -173,12 +143,12 @@ async function launch(app) {
   generation.closed = new Promise(resolve => child.once('close', (code, signal) => {
     generation.dead = true;
     if (child.pid) send({ type: 'child', pid: child.pid, running: false });
-    if (app.active === generation) app.active = null;
+    if (app.active === generation) {app.active = null;void app.gateway?.pause(generation).catch(error=>app.log.message(error.message));}
     if (!generation.expected) {
       app.log.message(`Process ${child.pid || 'unknown'} exited (${signal || code}).`);
       if (generation.ready) {
         // Serialize recovery and cleanup with explicit lifecycle commands.
-        sequence = sequence.then(async () => { await stopGeneration(app, generation, false); await persist(); retry(app, new Error(`Application exited (${signal || code})`)); }).catch(error => app.log.message(error.stack));
+        sequence = sequence.then(async () => { if(app.probation?.next===generation&&await rollback(app,new Error(`Replacement exited (${signal||code})`)))return;await stopGeneration(app, generation, false); await persist(); if(!app.active)retry(app, new Error(`Application exited (${signal || code})`)); }).catch(error => app.log.message(error.stack));
       }
     }
     resolve();
@@ -197,7 +167,42 @@ async function launch(app) {
   } catch (error) { await stopGeneration(app, generation, false); throw error; }
   finally { child.stdout.off('data', started); }
 }
+async function finishProbation(app){
+  const probation=app.probation;if(!probation)return;
+  clearTimeout(probation.timer);app.probation=null;
+  await stopGeneration(app,probation.previous).catch(error=>app.log.message(`Previous build cleanup: ${error.message}`));
+  await persist();
+}
+async function rollback(app,error){
+  const probation=app.probation;if(!probation)return false;
+  clearTimeout(probation.timer);app.probation=null;
+  if(!app.enabled||closing||probation.previous.dead||probation.previous.expected){
+    await stopGeneration(app,probation.previous,false);return false;
+  }
+  // A live previous process still has to pass its health check. Never roll
+  // traffic back to an instance whose dependencies have also become unhealthy.
+  try{await health(probation.previous,app.config,Math.min(2000,app.config.healthTimeout));await app.gateway.activate(probation.previous);}
+  catch(restore){app.log.message(`Rollback unavailable: ${restore.message}`);await stopGeneration(app,probation.previous,false);return false;}
+  app.active=probation.previous;app.state='online';app.error=`Rolled back: ${error.message}`;
+  app.log.message(`Rolled back to build ${app.active.buildId}: ${error.message}`);
+  await stopGeneration(app,probation.next);await persist();return true;
+}
+function beginProbation(app,next,previous){
+  const probation=app.probation={next,previous,deadline:Date.now()+app.config.rollbackWindow,failures:0};
+  const schedule=()=>{probation.timer=setTimeout(()=>{
+    sequence=sequence.then(async()=>{
+      if(app.probation!==probation||!app.enabled||closing)return;
+      if(next.dead){await rollback(app,new Error('Replacement exited during monitoring'));return;}
+      if(Date.now()>=probation.deadline){await finishProbation(app);return;}
+      try{await health(next,app.config,Math.min(2000,app.config.healthTimeout));probation.failures=0;}
+      catch(error){if(++probation.failures>=3){if(!await rollback(app,error)){await stopGeneration(app,next,false);retry(app,error);}return;}}
+      if(app.probation===probation)schedule();
+    }).catch(error=>app.log.message(`Replacement monitoring: ${error.stack||error}`));
+  },Math.min(1000,Math.max(1,probation.deadline-Date.now())));};
+  schedule();
+}
 async function activate(app) {
+  await finishProbation(app);
   await listen(app);
   const previous = app.active;
   const wasEnabled = app.enabled;
@@ -208,9 +213,13 @@ async function activate(app) {
     app.enabled = true;
     await persist();
     if (next.dead) throw new Error('Application exited before traffic could switch');
+    await app.gateway.activate(next);
+    if (next.dead) throw new Error('Application exited while traffic switched');
     app.active = next; app.state = 'online'; app.error = null;
     app.log.message(`Ready: pid ${next.child.pid}, build ${next.buildId || 'unknown'}, ${app.config.hostname}:${app.config.port}`);
   } catch (error) {
+    if (previous && !previous.dead) await app.gateway.activate(previous).catch(restore=>app.log.message(restore.message));
+    else await app.gateway?.pause().catch(restore=>app.log.message(restore.message));
     if (next) await stopGeneration(app, next, false).catch(cleanup => app.log.message(cleanup.message));
     app.enabled = wasEnabled;
     app.state = previous && !previous.dead ? 'online' : 'errored'; app.error = error.message;
@@ -218,21 +227,17 @@ async function activate(app) {
     app.log.message(`Start failed; ${previous && !previous.dead ? 'previous generation remains active' : 'no healthy generation'}: ${error.message}`);
     throw error;
   }
-  if (previous) {
-    await stopGeneration(app, previous).catch(error => app.log.message(`Previous build cleanup: ${error.message}`));
-    await persist();
-  }
+  if(previous && app.config.rollbackWindow>0)beginProbation(app,next,previous);
+  else if(previous){await stopGeneration(app,previous);await persist();}
 }
 async function stopApp(app) {
+  if(app.probation)clearTimeout(app.probation.timer);app.probation=null;
   app.enabled = false; clearTimeout(app.retry); app.retry = null;
   await persist();
   app.state = 'stopping'; app.active = null;
-  const gateway = app.gateway; app.gateway = null;
-  const closed = gateway ? new Promise(resolve => gateway.close(resolve)) : Promise.resolve();
-  gateway?.closeIdleConnections();
+  await app.gateway?.pause();
   await Promise.all([...app.generations].map(generation => stopGeneration(app, generation)));
-  for (const socket of app.sockets) socket.destroy();
-  await closed; app.state = 'stopped'; app.error = null; await persist();
+  await app.gateway?.close();app.gateway=null;app.state = 'stopped'; app.error = null; await persist();
   app.log.message('Stopped.');
 }
 function select(message) {
@@ -242,8 +247,12 @@ function select(message) {
   return selected;
 }
 async function command(message) {
-  if (message.command === 'status') return { daemonPid: process.pid, apps: [...apps.values()].map(summary) };
+  if (message.command === 'status') {
+    for(const app of apps.values())if(app.gateway){const counts=await app.gateway.counts();for(const g of app.generations)g.active=counts[g.relative]||0;}
+    return { daemonPid: process.pid, apps: [...apps.values()].map(summary) };
+  }
   if (message.command === 'start') {
+    message.config={rollbackWindow:15000,...message.config};
     validate(message.config);
     message.config.root = await realpath(message.config.root);
     let app = apps.get(message.config.name);
@@ -274,12 +283,13 @@ async function shutdown() {
   await sequence;
   // A supervisor shutdown preserves each enabled flag for the next launch.
   await Promise.all([...apps.values()].map(async app => {
-    clearTimeout(app.retry); app.active = null; app.gateway?.close();
+    if(app.probation)clearTimeout(app.probation.timer);app.probation=null;
+    clearTimeout(app.retry); app.active = null;await app.gateway?.pause();
     await Promise.all([...app.generations].map(generation => stopGeneration(app, generation)));
-    for (const socket of app.sockets) socket.destroy();
+    await app.gateway?.close();app.gateway=null;
     app.log.end();
   }));
-  await persist(); process.exit(0);
+  await stopNativeProxy();await persist(); process.exit(0);
 }
 process.on('disconnect', () => void shutdown());
 process.on('SIGTERM', () => void shutdown());

package/runtime/persistent/native-proxy.mjs

@@ -0,0 +1,63 @@
+// Lifecycle RPC only: no public HTTP bytes, headers or response bodies enter JS.
+import {spawn} from 'node:child_process';
+import {environment,delay} from './common.mjs';
+let manager;
+class NativeProxy {
+  constructor(binary,{home,notify,onFatal}){
+    this.pending=new Map();this.next=0;this.stopping=false;
+    this.child=spawn(binary,['persistent-proxy'],{cwd:home,windowsHide:true,detached:process.platform!=='win32',stdio:['pipe','pipe','inherit'],env:{...environment(),TOKIO_WORKER_THREADS:'1'}});
+    this.pid=this.child.pid;if(this.pid)notify({type:'child',pid:this.pid,running:true});
+    this.closed=new Promise(resolve=>this.child.once('close',()=>{if(this.pid)notify({type:'child',pid:this.pid,running:false});resolve();}));
+    this.ready=new Promise((resolve,reject)=>{
+      const timer=setTimeout(()=>{reject(new Error('Native persistent proxy did not initialize'));this.child.kill();},10000);timer.unref();
+      let buffer='';
+      this.child.stdout.setEncoding('utf8');
+      this.child.stdout.on('data',chunk=>{
+        buffer+=chunk;
+        if(buffer.length>1024*1024){this.child.kill();return;}
+        for(let end;(end=buffer.indexOf('\n'))>=0;){
+          const line=buffer.slice(0,end);buffer=buffer.slice(end+1);let message;
+          try{message=JSON.parse(line);}catch{this.child.kill();return;}
+          if(message.type==='ready'&&message.protocol===1){clearTimeout(timer);resolve();continue;}
+          const request=this.pending.get(message.id);if(!request)continue;
+          this.pending.delete(message.id);clearTimeout(request.timer);message.ok?request.resolve(message.value):request.reject(new Error(message.error||'Native proxy request failed'));
+        }
+      });
+      const failed=error=>{
+        clearTimeout(timer);reject(error);
+        for(const request of this.pending.values()){clearTimeout(request.timer);request.reject(error);}this.pending.clear();
+        if(!this.stopping)onFatal(error);
+      };
+      this.child.once('error',failed);this.child.once('exit',(code,signal)=>failed(new Error(`Native persistent proxy exited (${signal||code})`)));
+    });
+    this.child.stdin.on('error',()=>{});
+  }
+  async request(command,values={},timeout=10000){
+    await this.ready;
+    if(this.stopping||this.child.exitCode!==null||this.pending.size>=32)throw new Error('Native persistent proxy unavailable');
+    const id=++this.next;
+    return new Promise((resolve,reject)=>{
+      const timer=setTimeout(()=>{
+        this.pending.delete(id);reject(new Error('Native proxy control request timed out'));
+        // A timed-out switch/listen might still mutate native state later.
+        // End that uncertain control plane; the watchdog restores saved apps.
+        this.child.kill('SIGKILL');
+      },timeout);timer.unref();
+      this.pending.set(id,{resolve,reject,timer});
+      this.child.stdin.write(JSON.stringify({id,command,...values})+'\n',error=>{if(error){const request=this.pending.get(id);if(request){clearTimeout(request.timer);this.pending.delete(id);request.reject(error);}}});
+    });
+  }
+  async stop(){this.stopping=true;this.child.stdin.end();await Promise.race([this.closed,delay(3000)]);if(this.child.exitCode===null)this.child.kill('SIGKILL');await this.closed;}
+}
+export async function nativeGateway(config,options){
+  manager??=new NativeProxy(config.binary,options);await manager.ready;
+  const app=config.name;await manager.request('listen',{app,hostname:config.hostname,port:config.port});
+  return {pid:manager.pid,
+    activate:g=>manager.request('activate',{app,generation:g.relative,port:g.port}),
+    pause:g=>manager.request('pause',{app,...(g?{generation:g.relative}:{})}),
+    retire:(g,timeout)=>manager.request('retire',{app,generation:g.relative,timeout},timeout+5000),
+    counts:async()=> (await manager.request('status',{app})).generations,
+    close:()=>manager.request('close',{app}),
+  };
+}
+export async function stopNativeProxy(){if(manager){const active=manager;manager=undefined;await active.stop();}}

package/runtime/prefetch-scheduler.mjs

@@ -0,0 +1,110 @@
+const INTENT = 1;
+const abortError = () => Object.assign(new Error('Speculative navigation cancelled'), { name: 'AbortError' });
+
+// The completed-result cache obeys the same priority as the producer queue.
+// Otherwise a viewport scan could evict the hovered route immediately after
+// the scheduler had correctly protected its request.
+export function prefetchCacheVictim(cache, priority) {
+  let candidate;
+  for (const [key, entry] of cache) {
+    if (entry.abort.signal.aborted) return key;
+    if (!candidate || entry.priority < candidate[1].priority) candidate = [key, entry];
+  }
+  return candidate && candidate[1].priority <= priority ? candidate[0] : undefined;
+}
+
+// Speculative work never competes with a committed navigation. The same policy
+// is used by both routers; data and authorization remain in their own caches.
+export function createPrefetchScheduler({ window: win = globalThis.window, document: doc = globalThis.document,
+  concurrency = 2, limit = 8 } = {}) {
+  const tasks = new Set();
+  let serial = 0, active = 0, navigating = 0, disposed = false, scheduled = false;
+  const connection = win?.navigator?.connection;
+  const priorityOf = value => value === 'viewport' ? 0 : INTENT;
+  function policy(priority) {
+    const network = win?.navigator?.connection;
+    if (doc?.visibilityState === 'hidden' || win?.navigator?.onLine === false || network?.saveData || /^(slow-)?2g$/.test(network?.effectiveType || '')) return 0;
+    const slow = network?.effectiveType === '3g' || (network?.downlink > 0 && network.downlink < 1.5);
+    return slow ? (priority < INTENT ? 0 : 1) : concurrency;
+  }
+  function finish(task, error, value) {
+    if (!tasks.delete(task)) return;
+    if (task.running) active--;
+    task.abort.signal.removeEventListener('abort', task.cancelled);
+    const { resolve, reject } = task;
+    task.run = task.resolve = task.reject = task.cancelled = undefined;
+    error ? reject(error) : resolve(value);
+    wake();
+  }
+  function start(task) {
+    task.running = true; active++;
+    let result;
+    try { result = task.run(task.abort.signal); } catch (error) { finish(task, error); return; }
+    Promise.resolve(result).then(value => finish(task, null, value), error => finish(task, error));
+  }
+  function pump() {
+    scheduled = false;
+    if (disposed) return;
+    const queued = [...tasks].filter(task => !task.running).sort((a, b) => b.priority - a.priority || a.order - b.order);
+    for (const task of queued) {
+      if (!tasks.has(task)) continue;
+      if (task.priority === 2) { start(task); continue; }
+      if (navigating) break;
+      const slots = policy(task.priority);
+      if (!slots) { task.abort.abort(abortError()); continue; }
+      if (active >= slots) continue;
+      start(task);
+    }
+  }
+  function wake() {
+    if (scheduled || disposed) return;
+    scheduled = true; queueMicrotask(pump);
+  }
+  function changed() {
+    for (const task of tasks) if (task.priority !== 2 && !policy(task.priority)) task.abort.abort(abortError());
+    wake();
+  }
+  doc?.addEventListener?.('visibilitychange', changed);
+  win?.addEventListener?.('online', changed);
+  win?.addEventListener?.('offline', changed);
+  connection?.addEventListener?.('change', changed);
+  return {
+    schedule(run, { priority, abort = new AbortController() } = {}) {
+      const rank = priorityOf(priority);
+      if (disposed || abort.signal.aborted || !policy(rank)) return undefined;
+      if (tasks.size >= limit) {
+        // Keep intent ahead of broad viewport scans. Never evict demand work.
+        const oldest = [...tasks].filter(task => task.priority < 2).sort((a, b) => a.priority - b.priority || a.order - b.order)[0];
+        if (!oldest || oldest.priority > rank) return undefined;
+        oldest.abort.abort(abortError());
+      }
+      const task = { run, abort, priority: rank, order: serial++ };
+      const promise = new Promise((resolve, reject) => { task.resolve = resolve; task.reject = reject; });
+      // Cancellation also settles a task whose producer ignores AbortSignal.
+      // A late result cannot regain a queue slot or resurrect an invalid cache.
+      task.cancelled = () => finish(task, abort.signal.reason || abortError());
+      tasks.add(task); abort.signal.addEventListener('abort', task.cancelled, { once: true });
+      wake();
+      return { abort, promise,
+        promote(priority = 'intent') { if (tasks.has(task)) { task.priority = Math.max(task.priority, priorityOf(priority)); wake(); } },
+        demand() { if (tasks.has(task)) { task.priority = 2; wake(); } },
+      };
+    },
+    navigation(target) {
+      navigating++;
+      target?.demand();
+      for (const task of tasks) if (task.abort !== target?.abort && task.priority !== 2) task.abort.abort(abortError());
+      let released = false;
+      return () => { if (!released) { released = true; navigating--; wake(); } };
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      doc?.removeEventListener?.('visibilitychange', changed);
+      win?.removeEventListener?.('online', changed);
+      win?.removeEventListener?.('offline', changed);
+      connection?.removeEventListener?.('change', changed);
+      for (const task of tasks) task.abort.abort(abortError());
+    },
+  };
+}

package/runtime/preload.mjs

@@ -0,0 +1,12 @@
+import path from 'node:path';
+import {pathToFileURL} from 'node:url';
+// This is an import budget, not a total RSS limit. An individual module and its
+// transitive imports can exceed it; imported JavaScript cannot be unloaded.
+export async function preloadModules(files,{maxRssMb,timeoutMs},load=file=>import(pathToFileURL(file).href)){
+  const deadline=performance.now()+timeoutMs,loaded=[];
+  for(const file of files){
+    if(performance.now()>=deadline||process.memoryUsage().rss>=maxRssMb*1024*1024)break;
+    await load(path.resolve(file));loaded.push(file);
+  }
+  return loaded.length;
+}

package/runtime/profile.mjs

@@ -1,9 +1,23 @@
 import presets from './profiles.json' with { type: 'json' };
 
+export function rscResourceLimits(environment=process.env,production=environment.NODE_ENV!=='development'){
+  if(!production||/--max[-_]semi[-_]space[-_]size(?:[=\s]|$)/.test(environment.NODE_OPTIONS||''))return undefined;
+  return {maxYoungGenerationSizeMb:runtimeProfile(environment,production).youngGenerationMiB};
+}
+
 export function runtimeProfile(environment = process.env, production = environment.NODE_ENV !== 'development') {
   const requested = environment.PRNEXT_PROFILE || (environment.PRNEXT_MEMORY_PROFILE === 'compact' ? 'compact' : 'balanced');
   const name = requested === 'standard' ? 'classic' : requested;
   if (!Object.hasOwn(presets, name)) throw new Error(`Unknown runtime profile ${JSON.stringify(name)}; use ${Object.keys(presets).join(', ')}`);
   const effective = production ? name : 'classic';
+  if(production&&environment.PRNEXT_EFFECTIVE_PROFILE){
+    let value;
+    try{value=JSON.parse(environment.PRNEXT_EFFECTIVE_PROFILE);}catch{throw new Error('Invalid effective runtime profile');}
+    const settings=value?.[1],original=presets[effective];
+    if(!Array.isArray(value)||value.length!==2||value[0]!==effective||!settings||
+      Object.keys(settings).length!==Object.keys(original).length||Object.keys(original).some(key=>!Object.hasOwn(settings,key)||
+        (original[key]===null?settings[key]!==null&&(!Number.isSafeInteger(settings[key])||settings[key]<1):typeof original[key]==='boolean'?typeof settings[key]!=='boolean':!Number.isSafeInteger(settings[key])||settings[key]<1||settings[key]>Math.max(512,original[key]))))throw new Error('Invalid effective runtime profile');
+    return {name:effective,...settings};
+  }
   return { name: effective, ...presets[effective] };
 }

package/runtime/profiles.json

@@ -40,9 +40,9 @@
     "renderIdleSeconds": null
   },
   "memory": {
-    "optimizeForSize": true,
+    "optimizeForSize": false,
     "semiSpaceMiB": 2,
-    "youngGenerationMiB": 4,
+    "youngGenerationMiB": 8,
     "renderStarts": 8,
     "liveResponses": 28,
     "apiConcurrency": 64,

package/runtime/render.mjs

@@ -1,3 +1,4 @@
+import {reportRequestError} from './instrumentation.mjs';
 import { localePath } from '../compat/locale.cjs';
 import React from 'react';
 import DefaultApp, { loadGetInitialProps } from '../compat/app.cjs';
@@ -94,6 +95,7 @@ export async function renderPageRequest(options) {
   try { result = await renderPage({ ...options, capturedResponse }); }
   catch (error) {
     if ([400, 504].includes(error?.statusCode) || options.signal?.aborted) throw error;
+    reportRequestError(error);
     console.error('[prnext]', error?.stack || error);
     return renderPageError(options, { statusCode: 500, error, responseHeaders: capturedResponse.getHeaders() });
   }
@@ -266,6 +268,7 @@ export async function renderIsrPage(options) {
   catch (error) {
     if (!options.capturePageFailure) throw error;
     const pageFailure = summarizePageFailure(error);
+    reportRequestError(error);
     console.error('[prnext] Page generation failed:', pageFailure.stack || pageFailure.message);
     return { status: 500, headers: {}, body: Buffer.alloc(0), pageFailure };
   }

package/runtime/route-pattern.mjs

@@ -0,0 +1,44 @@
+/** Shared browser route matching; importing this never loads either router. */
+export function matchPagePattern(pattern, pathname) {
+  let segments;
+  try { segments = pathname.replace(/\/+$/, '').split('/').slice(1).map(decodeURIComponent); }
+  catch { return null; }
+  if (segments.length === 1 && !segments[0]) segments = [];
+  if (segments.some(segment => !segment || /[/\\\0]/.test(segment) || segment === '.' || segment === '..')) return null;
+  const parts = pattern === '/' ? [] : pattern.split('/').slice(1), params = Object.create(null), rank = [];
+  let index = 0;
+  for (const part of parts) {
+    const optional = /^\[\[\.\.\.([^\]]+)\]\]$/.exec(part);
+    const catchall = /^\[\.\.\.([^\]]+)\]$/.exec(part);
+    const parameter = /^\[([^\]]+)\]$/.exec(part);
+    if (optional || catchall) {
+      if (catchall && index === segments.length) return null;
+      if (index !== segments.length) params[(optional || catchall)[1]] = segments.slice(index);
+      index = segments.length; rank.push(optional ? 0 : 1);
+    } else if (parameter) {
+      if (index === segments.length) return null;
+      params[parameter[1]] = segments[index++]; rank.push(2);
+    } else {
+      if (segments[index++] !== part) return null;
+      rank.push(3);
+    }
+  }
+  return index === segments.length ? { params, rank } : null;
+}
+
+export function isHtmlDocumentRoute(routes, pathname) {
+  let winner;
+  for (const route of routes || []) {
+    const match = matchPagePattern(route.pattern, pathname);
+    if (!match) continue;
+    const rank = winner && (() => {
+      for (let index = 0; index < Math.max(match.rank.length, winner.rank.length); index++) {
+        const difference = (match.rank[index] ?? 4) - (winner.rank[index] ?? 4);
+        if (difference) return difference;
+      }
+      return 0;
+    })();
+    if (!winner || rank > 0) winner = { ...match, route };
+  }
+  return winner?.route.htmlOnly === true;
+}