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

package/runtime/api.mjs

@@ -178,6 +178,7 @@ function parseBody(bytes, contentType = '') {
 }
 
 export function runApi(options) {
+  if (options.timeoutMs === undefined && options.route?.cacheConfig?.maxDuration) options = { ...options, timeoutMs: options.route.cacheConfig.maxDuration * 1000 };
   return withCacheRequest(options, options.route?.router === 'app' ? 'route' : 'pages', context => runApiInner(options, context));
 }
 
@@ -189,11 +190,19 @@ async function runApiInner({ modulePath, route = {}, manifest = {}, production =
   const mod = (pages && loadedPagesModule(modulePath)) || await withSignal(loadModule(modulePath, pages), stream ? signal : undefined);
   const requestOriginal = originalUrl ? new URL(originalUrl, url) : undefined;
   if (requestOriginal) requestOriginal.pathname = removeBasePath(requestOriginal.pathname, manifest.config?.basePath || '');
-  const { request, bytes } = createRequest({ url, originalUrl: requestOriginal?.href, params, method, headers, body });
-  request.draftMode = cacheContext.draftMode;
-  request.previewData = cacheContext.previewData;
-  request.preview = cacheContext.previewData !== false;
-  if (typeof mod.default !== 'function') {
+  const appHandler = typeof mod.default !== 'function';
+  // App Route Handlers receive a NextRequest below. Constructing the Pages
+  // IncomingMessage here duplicates URL, header and cookie work and allocates
+  // an unused Duplex. Keep the existing Pages request path unchanged.
+  const { request, bytes } = appHandler
+    ? { bytes: Buffer.isBuffer(body) ? body : Buffer.from(body || '', 'base64') }
+    : createRequest({ url, originalUrl: requestOriginal?.href, params, method, headers, body });
+  if (!appHandler) {
+    request.draftMode = cacheContext.draftMode;
+    request.previewData = cacheContext.previewData;
+    request.preview = cacheContext.previewData !== false;
+  }
+  if (appHandler) {
     const {NextRequest, proxyRouteRequest} = await appRequestPrimitives();
     if (route.router === 'app' && manifest.dev) {
       const listing = await collectStaticParams({ page: mod, pageConfig: route.handlerConfig, segments: [] }, route.pattern);
@@ -221,6 +230,7 @@ async function runApiInner({ modulePath, route = {}, manifest = {}, production =
     const timeout = lifecycle && setTimeout(() => lifecycle.controller.abort(apiTimeoutError('response headers', timeoutMs)), timeoutMs);
     timeout?.unref();
     const pendingResponse = runRequestContext({ url, method, headers, params, production, cacheComponents: manifest.config?.cacheComponents, cacheLife: manifest.config?.cacheLife, cacheHandlers: manifest.config?.cacheHandlers, cacheHandler: manifest.config?.cacheHandler, cacheMaxMemorySize: manifest.config?.cacheMaxMemorySize, distDir: path.dirname(path.dirname(modulePath)), signal: lifecycle?.controller.signal || signal, previewModeId: manifest.previewModeId, basePath: manifest.config?.basePath || '', routePattern: route.pattern, cacheConfig: route.cacheConfig, phase: 'route', cacheState: cacheContext.cacheState, staticState: cacheContext.staticState, mutableCookies: true }, async () => {
+      currentRequest().afterScope = cacheContext.afterScope;
       let result;
       try { result = await handler(proxyRouteRequest(new NextRequest(requestOriginal || url, init), currentRequest()), { params: Promise.resolve(params) }); }
       catch (error) {

package/runtime/app-render.mjs

@@ -7,7 +7,7 @@ import { addBasePath, removeBasePath } from '../compat/paths.cjs';
 import { isDynamicBailout } from '../compat/dynamic-bailout.cjs';
 import { Readable } from 'node:stream';
 import { Worker } from 'node:worker_threads';
-import { workerMetadata } from './worker-metadata.mjs';
+import { workerMetadata, freezeClientModules, isImmutableClientModules } from './worker-metadata.mjs';
 import { workerArtifacts } from './worker-artifacts.mjs';
 import path from 'node:path';
 import { PARTIAL_PREFETCH_TYPE, PARTIAL_PREFETCH_BYTES } from './app-prefetch.mjs';
@@ -40,6 +40,7 @@ const edgeManifests = new WeakMap();
 const emptyManifest = Object.freeze({});
 let nextId = 0;
 const pending = new Map();
+const noop = () => {};
 // Avoid temporary arrays on every completion/cancellation at high concurrency.
 function hasPending(worker, minimum = 1, cancelledOnly = false) {
   let count = 0;
@@ -72,14 +73,14 @@ function flightDecoder(production) {
     // React's development decoder guards module initialization with NODE_ENV.
     // This require is synchronous; restore the host before any stream work.
     process.env.NODE_ENV = production ? 'production' : 'development';
-    let decoder = require(filename).createFromNodeStream;
-    if (typeof decoder !== 'function') {
+    let decoder = require(filename);
+    if (typeof decoder.createFromNodeStream !== 'function') {
       // A consumer may have previously required the guarded development file
       // in production, leaving an empty module in Node's cache.
       delete require.cache[filename];
-      decoder = require(filename).createFromNodeStream;
+      decoder = require(filename);
     }
-    if (typeof decoder !== 'function') throw new Error('React Flight decoder is unavailable for the requested render mode');
+    if (typeof decoder.createFromNodeStream !== 'function') throw new Error('React Flight decoder is unavailable for the requested render mode');
     flightDecoders.set(production, decoder);
     return decoder;
   } finally {
@@ -182,7 +183,7 @@ function getWorker(production) {
     }
     if (type === 'chunk') {
       try { request.channel.chunk(chunk, byteOffset, byteLength); }
-      catch (error) { request.channel.error(error); current.postMessage({ id, type: 'cancel' }); request.cancel(error); }
+      catch (error) { request.channel.error(error); current.postMessage({ id, type: 'cancel' }); request.cancel(error); return; }
       if (!done) return;
     }
     if (request.completed) {
@@ -194,6 +195,8 @@ function getWorker(production) {
     // work can legitimately continue afterwards and retains its own bounds;
     // supervise isolate responsiveness, not total background-task duration.
     clearTimeout(request.timeout);
+    // A destroyed Timeout can still own its AsyncLocalStorage frame.
+    request.timeout = undefined;
     request.releaseWorkWatch = workWatchdog.add();
     request.detach?.();
     if (type === 'end' || done) request.channel.end();
@@ -219,7 +222,11 @@ function getWorker(production) {
     // Keep only settlement bookkeeping after sending the body. The
     // isolate can still be flushing cache writes after its terminal frame.
     request.channel = undefined;
-    request.resolve = request.reject = () => {};
+    // Both closures capture the original response promise / AbortSignal.
+    // Detaching the listener alone does not release those references while
+    // legitimate background work keeps this entry in the pending map.
+    request.cancel = request.detach = undefined;
+    request.resolve = request.reject = noop;
   });
   current.on('error', fail);
   current.on('exit', code => fail(new Error(`App Router worker exited (${code})`), true));
@@ -227,12 +234,41 @@ function getWorker(production) {
   return current;
 }
 
+// Stdio workers can retain referenced MessagePorts after rendering (including
+// diagnostics piped from the RSC isolate). EOF must drain real cache/after()
+// settlement before explicitly closing those isolates, not wait for Node's
+// incidental event-loop liveness or terminate unfinished application work.
+export async function drainAppRuntime() {
+  while (pending.size) await Promise.all([...pending.values()].map(request => request.settled));
+  await closeAppRuntime();
+}
+
 export function closeAppRuntime() {
   const current = [...workers.values()];
   return Promise.all(current.map(worker => lifecycles.get(worker).terminate()));
 }
 
-export async function renderFlight(request, { softTimeoutMs = 25_000, hardTimeoutMs = 28_000, signal } = {}) {
+function requestDeadline(entry, lifecycle, id, hardTimeoutMs, delayMs) {
+  // Keep this callback outside renderFlight's request closure: cancelled work
+  // retains its hard deadline, but must not thereby retain the HTTP signal or
+  // response promise until an unrelated cache write settles.
+  return setTimeout(() => {
+    // A blocking npm dependency cannot honor an AbortSignal. Retire the
+    // isolate at the hard deadline so subsequent requests can recover.
+    void lifecycle.terminate(appTimeoutError('RSC worker', hardTimeoutMs)).finally(entry.settle).catch(error => console.error('[prnext] RSC worker termination failed:', error));
+    pending.delete(id);
+    entry.lease.release();
+    const error = appTimeoutError('RSC worker', hardTimeoutMs);
+    if (entry.completed) console.error('[prnext] RSC background work failed:', error);
+    entry.channel?.error(error);
+    entry.detach?.();
+    entry.reject(error);
+  }, delayMs);
+}
+
+export async function renderFlight(request, { softTimeoutMs, hardTimeoutMs, signal, deferFinalizer } = {}) {
+  softTimeoutMs ??= request.cacheConfig?.maxDuration ? request.cacheConfig.maxDuration * 1000 : 25_000;
+  hardTimeoutMs ??= request.cacheConfig?.maxDuration ? request.cacheConfig.maxDuration * 1000 : 28_000;
   const deadline = performance.now() + hardTimeoutMs;
   let current, lifecycle, lease;
   for (;;) {
@@ -254,20 +290,10 @@ export async function renderFlight(request, { softTimeoutMs = 25_000, hardTimeou
     current.ref();
     const id = ++nextId;
     let settle;
-    trackRequestWork(new Promise(resolve => { settle = resolve; }), signal, { deadline, supervised: true });
-    const timeout = setTimeout(() => {
-      // A blocking npm dependency cannot honor an AbortSignal. Retire the
-      // isolate at the hard deadline so subsequent requests can recover.
-      void lifecycle.terminate(appTimeoutError('RSC worker', hardTimeoutMs)).finally(settle).catch(error => console.error('[prnext] RSC worker termination failed:', error));
-      pending.delete(id);
-      lease.release();
-      const error = appTimeoutError('RSC worker', hardTimeoutMs);
-      if (entry.completed) console.error('[prnext] RSC background work failed:', error);
-      entry.channel?.error(error);
-      entry.detach?.();
-      reject(error);
-    }, Math.max(0, deadline - performance.now()));
-    const entry = { worker: current, resolve, reject, timeout, operation: request.operation, lease, settle };
+    const settled = new Promise(resolve => { settle = resolve; });
+    trackRequestWork(settled, signal, { deadline, supervised: true });
+    const entry = { worker: current, resolve, reject, operation: request.operation, lease, settle, settled };
+    const timeout = entry.timeout = requestDeadline(entry, lifecycle, id, hardTimeoutMs, Math.max(0, deadline - performance.now()));
     function cancel(reason) {
       if (entry.cancelled) return;
       // Keep the independent deadline until the isolate confirms settlement.
@@ -278,7 +304,11 @@ export async function renderFlight(request, { softTimeoutMs = 25_000, hardTimeou
       // Pause new work at 16 abandoned requests while their acknowledgements
       // settle. Existing mutation/cache work keeps its original hard deadline.
       if (!hasPending(current) && !lifecycle.retiring) current.unref();
-      reject(reason instanceof Error ? reason : new Error('App Router response was cancelled'));
+      entry.reject(reason instanceof Error ? reason : new Error('App Router response was cancelled'));
+      // Settlement/deadline tracking remains live, but a disconnected caller
+      // no longer needs its stream, promise or signal retained by this entry.
+      entry.channel = entry.cancel = entry.detach = undefined;
+      entry.resolve = entry.reject = noop;
     }
     entry.cancel = cancel;
     if (request.stream) entry.channel = parentStreamChannel(current, id, cancel);
@@ -294,6 +324,10 @@ export async function renderFlight(request, { softTimeoutMs = 25_000, hardTimeou
     pending.set(id, entry);
     try {
       const wire = { ...request, renderTimeoutMs: Math.min(softTimeoutMs, Math.max(1, deadline - performance.now())) };
+      if (request.action && deferFinalizer) {
+        wire.waitForResponse = true;
+        deferFinalizer(() => { if (pending.has(id)) current.postMessage({ id, type: 'after-response' }); });
+      }
       if (request.production) {
         const artifactId = artifacts.get(current)(wire.partialFlight);
         if (artifactId !== undefined) { wire.partialFlightId = artifactId; delete wire.partialFlight; }
@@ -317,11 +351,12 @@ export async function renderFlight(request, { softTimeoutMs = 25_000, hardTimeou
 }
 
 export async function decodeFlight(body, clientModules = {}, distDir, { production = process.env.NODE_ENV === 'production' } = {}) {
-  const ids = Object.keys(clientModules);
   let cached = ssrManifests.get(clientModules);
   // Keep only the manifest's module mapping, never a decoded React model or
   // request context. Weak ownership releases it with the build manifest.
-  if (!cached || cached.distDir !== distDir || ids.length !== cached.paths.size || ids.some(id => cached.paths.get(id) !== clientModules[id].ssrModule)) {
+  const immutable = isImmutableClientModules(clientModules);
+  const ids = cached && cached.distDir === distDir && cached.immutable && immutable ? null : Object.keys(clientModules);
+  if (!cached || cached.distDir !== distDir || (ids && (ids.length !== cached.paths.size || ids.some(id => cached.paths.get(id) !== clientModules[id].ssrModule)))) {
     const moduleMap = Object.create(null), paths = new Map();
     for (const id of ids) {
       const item = clientModules[id];
@@ -332,13 +367,20 @@ export async function decodeFlight(body, clientModules = {}, distDir, { producti
       moduleMap[id] = { '*': { id: moduleUrl, chunks: [moduleUrl, moduleUrl], name: '*' } };
       paths.set(id, item.ssrModule);
     }
-    cached = { distDir, paths, moduleMap };
+    cached = { distDir, paths, moduleMap, immutable };
     ssrManifests.set(clientModules, cached);
-  }
+  } else if (immutable) cached.immutable = true;
   // Hosts can build/render both modes in one process. The encoded protocol,
   // rather than the host's current environment or import cache, selects React.
   const decoder = flightDecoder(Boolean(production));
-  return decoder(body instanceof ReadableStream ? Readable.fromWeb(body) : Readable.from([body]), { moduleMap: cached.moduleMap, serverModuleMap: null, moduleLoading: null });
+  const serverConsumerManifest = { moduleMap: cached.moduleMap, serverModuleMap: null, moduleLoading: null };
+  // React's Node decoder can consume Web streams directly. Keep the Flight
+  // bytes in their original stream instead of allocating a Node Readable,
+  // forwarding its events and buffering a second queue for each response.
+  if (body instanceof ReadableStream && typeof decoder.createFromReadableStream === 'function') {
+    return decoder.createFromReadableStream(body, { serverConsumerManifest });
+  }
+  return decoder.createFromNodeStream(body instanceof ReadableStream ? Readable.fromWeb(body) : Readable.from([body]), serverConsumerManifest);
 }
 
 export async function renderHtml(tree, router, { timeoutMs = 25_000, formState = null, staticGeneration = false, nonce, strictMode = true } = {}) {
@@ -414,13 +456,16 @@ export async function renderAppPage(options) {
   return response;
 }
 
-async function renderAppPageInner({ modulePath, route = {}, manifest = {}, distDir = path.dirname(path.dirname(modulePath)), url = 'http://localhost/', originalUrl, params = {}, method = 'GET', headers = {}, routingRequestHeaders, routingResolver, body = '', production = process.env.NODE_ENV === 'production', stream = false, signal }) {
+async function renderAppPageInner({ modulePath, route = {}, manifest = {}, distDir = path.dirname(path.dirname(modulePath)), url = 'http://localhost/', originalUrl, params = {}, method = 'GET', headers = {}, routingRequestHeaders, routingResolver, body = '', production = process.env.NODE_ENV === 'production', stream = false, signal, deferFinalizer }) {
   let clientModules = manifest.app?.clientModules || emptyManifest;
   if (route.cacheConfig?.runtime === 'edge') {
     let edge = !manifest.dev && edgeManifests.get(clientModules);
     if (!edge) {
       edge = Object.fromEntries(Object.entries(clientModules).map(([id, item]) => [id, item.edgeSsrModule ? { ...item, ssrModule: item.edgeSsrModule } : item]));
-      if (!manifest.dev) edgeManifests.set(clientModules, edge);
+      if (!manifest.dev) {
+        if (isImmutableClientModules(clientModules)) freezeClientModules(edge);
+        edgeManifests.set(clientModules, edge);
+      }
     }
     clientModules = edge;
   }
@@ -490,7 +535,7 @@ async function renderAppPageInner({ modulePath, route = {}, manifest = {}, distD
   if (stream && (!request.action || request.action.id)) {
     let progressive;
     try {
-      progressive = await renderFlight({ ...request, stream: true }, { signal });
+      progressive = await renderFlight({ ...request, stream: true }, { signal, deferFinalizer });
       const rsc = Object.entries(headers).some(([name, value]) => name.toLowerCase() === 'rsc' && value === '1');
       if (rsc || request.action?.id) {
         if (method === 'HEAD') await progressive.body.cancel();
@@ -514,7 +559,7 @@ async function renderAppPageInner({ modulePath, route = {}, manifest = {}, distD
     }
   }
   let result;
-  try { result = await renderFlight(request, { signal }); }
+  try { result = await renderFlight(request, { signal, deferFinalizer }); }
   catch (error) {
     const result = navigationResponse(error);
     if (result) return { ...result, headers: { ...responseHeaders, ...result.headers, ...error.responseHeaders } };
@@ -531,7 +576,7 @@ async function renderAppPageInner({ modulePath, route = {}, manifest = {}, distD
   let html, model, recovery = false;
   try {
     model = await decodeFlight(result.body, clientModules, distDir, { production });
-    html = await renderHtml(model.tree, model.router, { formState: model.formState, nonce: request.nonce, strictMode: manifest.config?.reactStrictMode !== false });
+    html = await renderHtml(model.tree, model.router, { timeoutMs: route.cacheConfig?.maxDuration ? route.cacheConfig.maxDuration * 1000 : undefined, formState: model.formState, nonce: request.nonce, strictMode: manifest.config?.reactStrictMode !== false });
   } catch (error) {
     if (error?.statusCode === 504) throw error;
     const navigation = navigationResponse(error);

package/runtime/app-route-plan.mjs

@@ -0,0 +1,45 @@
+// Cache only the compiler-owned, immutable routing scaffold. Component modules,
+// configuration, request parameters and rendered trees are never memoized here.
+const plans = new WeakMap();
+const liveTrees = new WeakSet();
+const ownValue = (object, name) => Object.getOwnPropertyDescriptor(object, name)?.value;
+function frozenRecord(value) {
+  if (!value || typeof value !== 'object' || !Object.isFrozen(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  if (Array.isArray(value) ? prototype !== Array.prototype : prototype !== Object.prototype && prototype !== null) return false;
+  if (Array.isArray(value) && Object.hasOwn(value, Symbol.iterator)) return false;
+  return Reflect.ownKeys(value).every(key => 'value' in Object.getOwnPropertyDescriptor(value, key));
+}
+
+/** Mutable development/custom trees continue through the live traversal. */
+export function appRoutePlan(root) {
+  if (!root || !Object.isFrozen(root)) return null;
+  const existing = plans.get(root);
+  if (existing) return existing;
+  if (liveTrees.has(root)) return null;
+  const pages = [], nodes = new Map(), rootLayouts = new Set();
+  let sequence = 0;
+  function visit(node, chain, branch, hasLayout) {
+    if (!frozenRecord(node)) return false;
+    const children = ownValue(node, 'children'), slots = ownValue(node, 'slots'), files = ownValue(node, 'files');
+    if (!Array.isArray(children) || !frozenRecord(children) || !frozenRecord(slots) || !frozenRecord(files)
+      || typeof ownValue(node, 'path') !== 'string' || typeof ownValue(node, 'pattern') !== 'string'
+      || typeof ownValue(node, 'segment') !== 'string' || nodes.has(node)) return false;
+    // Bound retained chains even for hand-written frozen manifests.
+    if (sequence >= 4096 || chain.length >= 64) return false;
+    const next = [...chain, node], start = sequence++;
+    const info = { start, end: start, depth: chain.length, branch, slots: Object.entries(slots), metadataSlots: Object.entries(slots).sort(([a], [b]) => a.localeCompare(b)) };
+    nodes.set(node, info);
+    if (files.layout && !hasLayout) rootLayouts.add(node.path);
+    if (files.page) pages.push({ node, chain: next, start, branch,
+      score: node.pattern.split('/').filter(Boolean).reduce((sum, value) => sum + (value.startsWith('[[...') ? 0 : value.startsWith('[...') ? 1 : value.startsWith('[') ? 3 : 6), 0) });
+    for (const child of children) if (!visit(child, next, branch, hasLayout || !!files.layout)) return false;
+    for (const child of Object.values(slots)) if (!visit(child, next, child, hasLayout || !!files.layout)) return false;
+    info.end = sequence;
+    return true;
+  }
+  if (!visit(root, [], root, false)) { liveTrees.add(root); return null; }
+  const plan = { pages, nodes, rootLayouts };
+  plans.set(root, plan);
+  return plan;
+}

package/runtime/app-routing-state.mjs

@@ -1,26 +1,98 @@
 // Route matching and navigation state do not need React or metadata rendering.
 import { removeBasePath } from '../compat/paths.cjs';
 
-export function matchAppPattern(pattern, pathname, prefix = false) {
-  const expected = pattern.split('/').filter(Boolean), raw = pathname.split('/').filter(Boolean);
-  let parts;
-  try { parts = raw.map(decodeURIComponent); } catch { return null; }
-  const params = {};
-  for (let index = 0; index < expected.length; index++) {
-    const segment = expected[index];
+// Only trusted route syntax is cached, never URLs, decoded parameters or request
+// state. Bound the shared lookup's entry count and retained text/segments.
+const patterns = new Map();
+// Live manifest entries own their parsed syntax weakly. Large route tables must
+// not churn the bounded cross-call cache once for every saved parallel slot.
+// Their lifetime follows the existing manifest; no old manifest is retained.
+// Re-read the pattern on each use so mutable development manifests stay live.
+const routePatterns = new WeakMap();
+let patternCharacters = 0, patternSegments = 0;
+function compilePattern(pattern) {
+  let compiled = patterns.get(pattern);
+  if (compiled) return compiled;
+  const segments = pattern.split('/').filter(Boolean);
+  const kinds = new Uint8Array(segments.length);
+  let score = 0;
+  for (let index = 0; index < segments.length; index++) {
+    const segment = segments[index];
+    if (segment[0] !== '[') { score += 6; continue; }
+    score += segment.startsWith('[[...') ? 0 : segment.startsWith('[...') ? 1 : 3;
     const optional = /^\[\[\.\.\.([^\]]+)\]\]$/.exec(segment);
     const catchAll = /^\[\.\.\.([^\]]+)\]$/.exec(segment);
     if (optional || catchAll) {
-      if (catchAll && index >= parts.length) return null;
-      if (index < parts.length) params[(optional || catchAll)[1]] = parts.slice(index);
-      return params;
+      kinds[index] = optional ? 3 : 2;
+      segments[index] = (optional || catchAll)[1];
+    } else {
+      const dynamic = /^\[([^\]]+)\]$/.exec(segment);
+      if (dynamic) { kinds[index] = 1; segments[index] = dynamic[1]; }
+    }
+  }
+  compiled = { segments, kinds, score, characters: pattern.length };
+  if (pattern.length <= 2048 && segments.length <= 64) {
+    while (patterns.size >= 1024 || patternCharacters + pattern.length > 128 * 1024 || patternSegments + segments.length > 8192) {
+      const oldest = patterns.keys().next().value;
+      const removed = patterns.get(oldest);
+      patterns.delete(oldest);
+      patternCharacters -= removed.characters;
+      patternSegments -= removed.segments.length;
     }
-    const dynamic = /^\[([^\]]+)\]$/.exec(segment);
-    if (index >= parts.length) return null;
-    if (dynamic) params[dynamic[1]] = parts[index];
-    else if (segment !== parts[index]) return null;
+    patterns.set(pattern, compiled);
+    patternCharacters += pattern.length;
+    patternSegments += segments.length;
   }
-  return prefix || expected.length === parts.length ? params : null;
+  return compiled;
+}
+
+function pathSegments(pathname) {
+  const raw = pathname.split('/').filter(Boolean);
+  try { return raw.map(decodeURIComponent); }
+  catch { return null; }
+}
+
+function compiledRoute(route) {
+  const pattern = route.pattern;
+  const cached = routePatterns.get(route);
+  if (cached && cached.pattern === pattern) return cached.compiled;
+  const compiled = compilePattern(pattern);
+  if (pattern.length <= 2048 && compiled.segments.length <= 64) routePatterns.set(route, { pattern, compiled });
+  else routePatterns.delete(route);
+  return compiled;
+}
+
+function matchesParts({ segments, kinds }, parts, prefix = false, params) {
+  for (let index = 0; index < segments.length; index++) {
+    const kind = kinds[index];
+    if (kind >= 2) {
+      if (kind === 2 && index >= parts.length) return false;
+      if (params && index < parts.length) params[segments[index]] = parts.slice(index);
+      return true;
+    }
+    if (index >= parts.length) return false;
+    if (kind === 1) { if (params) params[segments[index]] = parts[index]; }
+    else if (segments[index] !== parts[index]) return false;
+  }
+  return prefix || segments.length === parts.length;
+}
+
+export function matchAppPattern(pattern, pathname, prefix = false) {
+  const compiled = compilePattern(pattern), parts = pathSegments(pathname);
+  if (!parts) return null;
+  const params = {};
+  return matchesParts(compiled, parts, prefix, params) ? params : null;
+}
+
+/** Decode a request pathname once; each match still owns its parameter values. */
+export function createAppMatcher(pathname) {
+  const parts = pathSegments(pathname);
+  return (pattern, prefix = false) => {
+    const compiled = compilePattern(pattern);
+    if (!parts) return null;
+    const params = {};
+    return matchesParts(compiled, parts, prefix, params) ? params : null;
+  };
 }
 
 export function readRouterState(request) {
@@ -49,13 +121,21 @@ export function advancedRoutingSources(request, routes) {
   const modules = new Set();
   for (const saved of Object.values(state.slots)) {
     const pathname = new URL(saved.url, 'http://prnext.local').pathname;
-    const route = routes.filter(item => item.router === 'app' && item.kind === 'page' && !item.internal && matchAppPattern(item.pattern, pathname))
-      .sort((a, b) => score(b.pattern) - score(a.pattern))[0];
+    const parts = pathSegments(pathname);
+    if (!parts) continue;
+    let route, bestScore = -1;
+    for (let index = 0, length = routes.length; index < length; index++) {
+      if (!(index in routes)) continue;
+      const item = routes[index];
+      if (item.router !== 'app' || item.kind !== 'page' || item.internal) continue;
+      const compiled = compiledRoute(item);
+      // The original stable sort kept the first route when scores were equal.
+      // Lower-scoring routes cannot replace a match already found.
+      if (compiled.score <= bestScore || !matchesParts(compiled, parts)) continue;
+      route = item;
+      bestScore = compiled.score;
+    }
     if (route) modules.add(route.module);
   }
   return [...modules];
 }
-
-function score(pattern) {
-  return pattern.split('/').filter(Boolean).reduce((sum, value) => sum + (value.startsWith('[[...') ? 0 : value.startsWith('[...') ? 1 : value.startsWith('[') ? 3 : 6), 0);
-}

package/runtime/app-routing.mjs

@@ -6,8 +6,9 @@ import path from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { currentRequest, runRequestContext } from '../compat/headers.cjs';
 import { staticParams } from '../compat/static-generation.cjs';
+import { appRoutePlan } from './app-route-plan.mjs';
 
-import { matchAppPattern, readRouterState } from './app-routing-state.mjs';
+import { matchAppPattern, createAppMatcher, readRouterState } from './app-routing-state.mjs';
 export { matchAppPattern, readRouterState, advancedRoutingSources } from './app-routing-state.mjs';
 
 export async function loadAdvancedRouting(entry, request) {
@@ -51,10 +52,12 @@ function selectedSegments(chain, params) {
 /** Parallel slots retain their original Flight children on soft navigation. */
 export function createAdvancedTree(entry, request, searchParams) {
   const pathname = removeBasePath(new URL(request.url).pathname, request.basePath || '');
+  const matchCurrent = createAppMatcher(pathname);
   const old = readRouterState(request), slots = {}, activeParams = { ...request.params };
   const rebuild = !!old && (old.refresh || old.restore || request.method === 'POST');
   let invalid = false;
   const root = entry.routing;
+  const plan = appRoutePlan(root);
   let metadataHead;
   const keyScopes = new Map();
   const instantTrees = [];
@@ -62,18 +65,20 @@ export function createAdvancedTree(entry, request, searchParams) {
     if (request.partialParams?.length) keyScopes.set(key, { key, prefix, suffix, names: Object.keys(values), pattern: node.pattern, ...(liveProps ? { liveProps } : {}), ...(segments ? { segments } : {}) });
     return key;
   }
-  const rootLayouts = new Set();
+  const rootLayouts = plan?.rootLayouts || new Set();
   const metadataSelections = new Map();
   let missing = entry.interceptionOnly && !old, rootPage;
   const all = [];
   function walk(node, chain = []) {
     const next = [...chain, node];
     if (node.files.layout && !chain.some(parent => parent.files.layout)) rootLayouts.add(node.path);
-    if (node.files.page) all.push({ node, chain: next, params: matchAppPattern(node.pattern, pathname) });
+    if (node.files.page) all.push({ node, chain: next, params: matchCurrent(node.pattern) });
     for (const child of node.children) walk(child, next);
     for (const child of Object.values(node.slots)) walk(child, next);
   }
-  walk(root);
+  if (plan) {
+    for (const page of plan.pages) all.push({ ...page, params: matchCurrent(page.node.pattern) });
+  } else walk(root);
   let activeInterceptions;
   function canIntercept(candidate) {
     if (!candidate.node.interception || !old) return false;
@@ -97,14 +102,29 @@ export function createAdvancedTree(entry, request, searchParams) {
   function candidates(node, chain = []) {
     const result = [], next = [...chain, node];
     if (node.files.page) {
-      const params = matchAppPattern(node.pattern, pathname);
+      const params = matchCurrent(node.pattern);
       if (params && (!node.interception || canIntercept({ node }))) result.push({ node, chain: next, params });
     }
     for (const child of node.children) result.push(...candidates(child, next));
     return result.sort((left, right) => Number(!!right.node.interception) - Number(!!left.node.interception) || score(right.node.pattern) - score(left.node.pattern));
   }
+  function firstCandidate(node) {
+    if (!plan) return candidates(node)[0];
+    const scope = plan.nodes.get(node);
+    let best;
+    for (const candidate of all) {
+      if (!candidate.params || candidate.branch !== scope.branch || candidate.start < scope.start || candidate.start >= scope.end
+        || (candidate.node.interception && !canIntercept(candidate))) continue;
+      if (!best || Number(!!candidate.node.interception) > Number(!!best.node.interception)
+        || (!!candidate.node.interception === !!best.node.interception && candidate.score > best.score)) best = candidate;
+    }
+    // Separate request-owned params from the interception/scaffolding candidates,
+    // as in the live traversal. No parameter objects survive this request.
+    return best && { node: best.node, chain: best.chain.slice(scope.depth), params: matchCurrent(best.node.pattern) };
+  }
+  const slotEntries = node => plan?.nodes.get(node).slots || Object.entries(node.slots);
   function scopedParams(node) {
-    const current = matchAppPattern(node.pattern, pathname, true) || (old && matchAppPattern(node.pattern, old.source, true));
+    const current = matchCurrent(node.pattern, true) || (old && matchAppPattern(node.pattern, old.source, true));
     if (current) return current;
     for (const [key, value] of Object.entries(old?.slots || {})) {
       if (!key.startsWith(`${node.path}::`)) continue;
@@ -117,7 +137,7 @@ export function createAdvancedTree(entry, request, searchParams) {
     return registerKey(`${node.path}::${JSON.stringify(scopedParams(node))}`, node, `${node.path}::`);
   }
   function sourceURL(node, previous) {
-    return matchAppPattern(node.pattern, pathname, true) ? pathname + new URL(request.url).search : previous?.source || previous?.url || old?.source || pathname;
+    return matchCurrent(node.pattern, true) ? pathname + new URL(request.url).search : previous?.source || previous?.url || old?.source || pathname;
   }
   function accessURL(url, previous) {
     if (previous?.url === url && previous.accessUrl) return previous.accessUrl;
@@ -148,8 +168,7 @@ export function createAdvancedTree(entry, request, searchParams) {
   function slot(node, owner, name) {
     const key = registerKey(`${scope(owner)}::${name}`, owner, `${owner.path}::`, `::${name}`, ['id']);
     const previous = old?.slots[key];
-    let choices = candidates(node);
-    let selected = rebuild && previous ? savedBranch(node, previous) : choices[0];
+    let selected = rebuild && previous ? savedBranch(node, previous) : firstCandidate(node);
     if (rebuild && previous && !selected) { invalid = true; return { tree: null, segments: [] }; }
     if (!rebuild) {
       for (const candidate of interceptions) {
@@ -189,9 +208,9 @@ export function createAdvancedTree(entry, request, searchParams) {
       // Find the nearest default whose route prefix contains the destination.
       const defaults = [];
       function findDefault(value, chain = []) {
-        if (!matchAppPattern(value.pattern, pathname, true) || (value.interception && !old)) return;
+        if (!matchCurrent(value.pattern, true) || (value.interception && !old)) return;
         const next = [...chain, value];
-        if (value.files.default) defaults.push({ node: value, chain: next, params: matchAppPattern(value.pattern, pathname, true), default: true });
+        if (value.files.default) defaults.push({ node: value, chain: next, params: matchCurrent(value.pattern, true), default: true });
         for (const child of value.children) findDefault(child, next);
       }
       findDefault(node);
@@ -207,9 +226,9 @@ export function createAdvancedTree(entry, request, searchParams) {
     let selectedTree = renderPath(selected.chain, selected, 0, name === 'children' && owner === node);
     const context = request.routingContexts?.get(selectedURL);
     if (context && request.renderRoutingBranch) selectedTree = request.renderRoutingBranch(selectedTree, context);
-    const instant=selected.node.config?.page?.instant ?? [...selected.chain].reverse().find(item=>item.config?.layout?.instant!==undefined)?.config.layout.instant;
-    if(request.instantValidation && name!=='children' && instantEnabled(instant,request.production)){
-      instantTrees.push({path:(owner.path || '/')+' @'+name,tree:selectedTree});
+    if(request.instantValidation && name!=='children'){
+      const instant=selected.node.config?.page?.instant ?? selected.chain.findLast(item=>item.config?.layout?.instant!==undefined)?.config.layout.instant;
+      if(instantEnabled(instant,request.production)) instantTrees.push({path:(owner.path || '/')+' @'+name,tree:selectedTree});
     }
     return { tree: React.createElement(entry.LayoutSlot, { key, id: key, preserve: false }, selectedTree), segments: selected.default ? [] : selectedSegments(selected.chain.slice(node === owner ? 1 : 0), selected.params) };
   }
@@ -248,7 +267,7 @@ export function createAdvancedTree(entry, request, searchParams) {
     const selected = { children: selection.default ? [] : selectedSegments(chain.slice(index + 1), selection.params) };
     if (preserveChild) selected.children = null;
     const parallel = {};
-    for (const [name, child] of Object.entries(node.slots)) {
+    for (const [name, child] of slotEntries(node)) {
       const rendered = slot(child, node, name);
       parallel[name] = rendered.tree; selected[name] = rendered.segments;
     }
@@ -286,7 +305,7 @@ export function createAdvancedTree(entry, request, searchParams) {
       if (layout) metadataItems.push({ module: node.files.layout, params: staticParams(layout.params, currentRequest()), filePath: page ? undefined : node.path, context: layout.context });
       // Next orders paths containing named slots before ordinary children,
       // with slot names in locale order (compareAppPaths in its app loader).
-      for (const [, child] of Object.entries(node.slots).sort(([a], [b]) => a.localeCompare(b))) visit(child);
+      for (const [, child] of plan?.nodes.get(node).metadataSlots || Object.entries(node.slots).sort(([a], [b]) => a.localeCompare(b))) visit(child);
       if (page) metadataItems.push({ module: node.files[page.default ? 'default' : 'page'], params: staticParams(page.params, currentRequest()), searchParams: page.searchParams || searchParams, filePath: node.path, context: request.routingContexts?.get(page.url) });
       for (const child of node.children) visit(child);
     }
@@ -300,7 +319,7 @@ export function createAdvancedTree(entry, request, searchParams) {
   metadataHead = head;
   const main = slot(root, root, 'children');
   const parallel = {}, selected = { children: main.segments };
-  for (const [name, child] of Object.entries(root.slots)) {
+  for (const [name, child] of slotEntries(root)) {
     const result = slot(child, root, name);
     parallel[name] = result.tree; selected[name] = result.segments;
   }
@@ -310,7 +329,7 @@ export function createAdvancedTree(entry, request, searchParams) {
     const content = React.createElement(React.Fragment, null, main.tree, ...Object.values(parallel));
     instantTrees.push({ path: root.path || '/', tree: root.files.loading ? React.createElement(React.Suspense, { fallback: React.createElement(component(root.files.loading, 'loading')) }, content) : content });
   }
-  const instantDisabled = all.flatMap(item => item.chain).some(node => Object.values(node.config || {}).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 && all.some(item => item.chain.some(node => Object.values(node.config || {}).some(config => config.instant && typeof config.instant === 'object' && (config.instant.unstable_disableValidation || (request.production ? config.instant.unstable_disableBuildValidation : config.instant.unstable_disableDevValidation)))));
   let tree = wrap(root, main.tree, parallel, selected, scope(root), {}, rootPage?.chain.slice(1).map(item => item.segment), rootPage?.node);
   if (missing) {
     request.responseStatus = 404;