fix: do not treat a failed prefetch as a recovery, or re-render a chainless boundary

The retained-frame clear infers that a render succeeded from the frame it
captured still being current, and that inference holds only when a sink was
installed to write a new one. A prefetch installs none, so a prefetch of a
url whose not-found throws AGAIN looked exactly like a recovery and wiped a
frame that was still current, which is the gap the retention exists to
close. The matched-page branch gates its whole supersede closure on
!isPrefetch for this reason; this one was gated only on dev.

The standalone fallback also ran when no route was supplied, where there is
no layout chain and the try body already ran that exact renderToString. It
re-executed the boundary tree to learn nothing, and a tree that is not
idempotent under re-render could succeed on the retry and be reported as a
layout crash that never happened.

Author: vivek7405

packages/server/src/dev/serve.js

@@ -510,7 +510,15 @@ export async function handleCore(req, ctx) {
   // page that has since recovered. Scoped to this url, so a good render here
   // never erases an error still current for a page the user is looking at.
   const devErrorUrl = withBasePath(url.pathname, basePath()) + url.search;
-  const before = dev ? state.lastDevError : null;
+  // Gated on !isPrefetch as well as dev, exactly as the matched-page branch
+  // gates its whole supersede closure. The clear below infers "this render
+  // succeeded" from "the retained frame is still the one I captured", and that
+  // inference is only valid when a sink was installed to write a new one. A
+  // prefetch installs none, so a prefetch of a url that throws AGAIN would
+  // look like a recovery and wipe a frame that is still current, which is the
+  // #893 gap the retention exists to close.
+  const isPrefetch = req.headers.get('x-webjs-prefetch') === '1';
+  const before = dev && !isPrefetch ? state.lastDevError : null;
   const resp = await ssrNotFound(state.routeTable.notFound || state.routeTable.globalNotFound, {
     dev,
     appDir,
@@ -531,7 +539,7 @@ export async function handleCore(req, ctx) {
     // raise an overlay on the page you are actually on, nor become
     // `state.lastDevError` for the SSE to replay into a fresh tab. Prefetch is
     // on by default and fetches unrouted hrefs too, so this is reachable.
-    onDevError: dev && req.headers.get('x-webjs-prefetch') !== '1'
+    onDevError: dev && !isPrefetch
       ? (e) => reportDevError(e, { kind: 'render', url: devErrorUrl })
       : undefined,
   });

packages/server/src/ssr/render.js

@@ -701,6 +701,14 @@ async function ssrBoundaryHtml(file, heading, opts) {
             body = await renderToString(tree, { ssr: true, dev: opts.dev });
           }
         } catch (layoutErr) {
+          // With no route there was no layout chain: the try body already ran
+          // this exact `renderToString(tree)`, so re-running it would execute
+          // the boundary tree a second time to learn nothing, and a tree that
+          // is not idempotent under re-render (a hole holding a one-shot async
+          // iterable, say) could even SUCCEED on the retry and be reported as
+          // a layout crash that never happened. Rethrow: the outer catch
+          // reports it once, under the boundary label.
+          if (!opts.route) throw layoutErr;
           // Always attempt the standalone render, which is the degradation
           // this path has always produced. Its OUTCOME is half the diagnosis
           // and the phase marker is the other half; neither alone is enough.
@@ -793,7 +801,9 @@ async function ssrNotFoundHtml(notFoundFile, opts) {
             body = await renderToString(tree, { ssr: true, dev: opts.dev });
           }
         } catch (layoutErr) {
-          // Same diagnosis rule as ssrBoundaryHtml above.
+          // Same diagnosis rule as ssrBoundaryHtml above, including the
+          // no-route short-circuit.
+          if (!opts.route) throw layoutErr;
           let treeErr = null;
           try {
             body = await renderToString(tree, { ssr: true, dev: opts.dev });

packages/server/test/routing/global-boundaries.test.js

@@ -222,3 +222,32 @@ export default function NF() {
   const held = app.getLastDevError();
   assert.equal(held, null, 'no stale frame retained for a url that recovered');
 });
+
+test('a PREFETCH that fails again does not wipe a still-current overlay frame', async () => {
+  // The clear infers "this render succeeded" from "the retained frame is still
+  // the one I captured". A prefetch installs no sink, so a prefetch of a url
+  // that throws AGAIN writes no frame and would look exactly like a recovery.
+  // The url is still broken; wiping the frame is the #893 gap the retention
+  // exists to close.
+  const appDir = makeApp({
+    'package.json': pkg,
+    'app/page.js': page('export default function H() { return html`<main>home</main>`; }'),
+    'app/not-found.js':
+      `export default function NF() { throw new Error('STILL_BROKEN_NF'); }\n`,
+  });
+  const app = await createRequestHandler({ appDir, dev: true });
+  const prev = console.error;
+  console.error = () => {};
+  try {
+    await app.handle(new Request('http://x/gone'));
+    const held = app.getLastDevError();
+    assert.ok(held, 'the first, real navigation retained a frame');
+    assert.match(String(held.url), /\/gone$/);
+
+    // Now hover a link to it. Same url, still broken, speculative.
+    await app.handle(new Request('http://x/gone', { headers: { 'x-webjs-prefetch': '1' } }));
+  } finally { console.error = prev; }
+  const after = app.getLastDevError();
+  assert.ok(after, 'the frame survives a prefetch that failed again');
+  assert.match(String(after.url), /\/gone$/);
+});