diff --git a/packages/cloudflare/src/cache/cdn-adapter.runtime.ts b/packages/cloudflare/src/cache/cdn-adapter.runtime.ts
index 6a6ff17fb..4d75cecde 100644
--- a/packages/cloudflare/src/cache/cdn-adapter.runtime.ts
+++ b/packages/cloudflare/src/cache/cdn-adapter.runtime.ts
@@ -149,9 +149,15 @@ export class CloudflareCdnCacheAdapter implements CdnCacheAdapter {
     }
 
     // A non-cacheable policy (no-store / no-cache / private) must never be
-    // promoted to an edge cache — pass it through unchanged.
+    // promoted to an edge cache. Clear any cacheable headers this adapter owns
+    // in case middleware stamped them before the final policy was known.
     if (/\b(?:no-store|no-cache|private)\b/.test(input.cacheControl)) {
-      return { "Cache-Control": input.cacheControl };
+      return {
+        "Cache-Control": input.cacheControl,
+        "CDN-Cache-Control": null,
+        "Cloudflare-CDN-Cache-Control": null,
+        "Cache-Tag": null,
+      };
     }
 
     // SWR policy on CDN-Cache-Control (edge caches + revalidates); the browser
diff --git a/packages/vinext/src/entries/app-rsc-entry.ts b/packages/vinext/src/entries/app-rsc-entry.ts
index 4ac104d6d..80ffffaa5 100644
--- a/packages/vinext/src/entries/app-rsc-entry.ts
+++ b/packages/vinext/src/entries/app-rsc-entry.ts
@@ -714,6 +714,7 @@ export default __createAppRscHandler({
       getSourceRoute(sourceRouteIndex) {
         return routes[sourceRouteIndex];
       },
+      hasCustomGlobalError: ${globalErrorVar ? `Boolean(${globalErrorVar}?.default)` : "false"},
       hasGenerateStaticParams: __generateStaticParams.length > 0,
       hasPageDefaultExport: !!PageComponent,
       hasPageModule: !!route.page,
diff --git a/packages/vinext/src/index.ts b/packages/vinext/src/index.ts
index 5b6963241..173e940fe 100644
--- a/packages/vinext/src/index.ts
+++ b/packages/vinext/src/index.ts
@@ -190,7 +190,7 @@ import { createRequire } from "node:module";
 import fs from "node:fs";
 import { randomBytes, randomUUID } from "node:crypto";
 import commonjs from "vite-plugin-commonjs";
-import { normalizePathSeparators, stripViteModuleQuery } from "./utils/path.js";
+import { normalizePathSeparators, stripJsExtension, stripViteModuleQuery } from "./utils/path.js";
 import { getViteMajorVersion } from "./utils/vite-version.js";
 
 // Install the process-level peer-disconnect backstop at module load.
@@ -2504,7 +2504,7 @@ export default function vinext(options: VinextOptions = {}): PluginOption[] {
         // direct @vercel/og imports in metadata routes, and \0-prefixed
         // re-imports from @vitejs/plugin-rsc.
         filter: {
-          id: /(?:next\/|virtual:vinext-|^@vercel\/og(?:\.js)?$)/,
+          id: /(?:next\/|vinext\/shims\/|virtual:vinext-|@vercel\/og(?:\.js)?$)/,
         },
         handler(id, importer) {
           // Strip \0 prefix if present — @vitejs/plugin-rsc's generated
@@ -2517,6 +2517,14 @@ export default function vinext(options: VinextOptions = {}): PluginOption[] {
             return resolveShimModulePath(_shimsDir, "og");
           }
 
+          const vinextShimPrefix = "vinext/shims/";
+          if (cleanId.startsWith(vinextShimPrefix)) {
+            return resolveShimModulePath(
+              _shimsDir,
+              stripJsExtension(stripViteModuleQuery(cleanId.slice(vinextShimPrefix.length))),
+            );
+          }
+
           // Pages Router virtual modules
           if (cleanId === VIRTUAL_SERVER_ENTRY) return RESOLVED_SERVER_ENTRY;
           if (cleanId === VIRTUAL_CLIENT_ENTRY) return RESOLVED_CLIENT_ENTRY;
diff --git a/packages/vinext/src/server/app-browser-entry.ts b/packages/vinext/src/server/app-browser-entry.ts
index 6e2a24a2a..ec4217bd9 100644
--- a/packages/vinext/src/server/app-browser-entry.ts
+++ b/packages/vinext/src/server/app-browser-entry.ts
@@ -18,7 +18,7 @@ import {
   setServerCallback,
 } from "@vitejs/plugin-rsc/browser";
 import { flushSync } from "react-dom";
-import { hydrateRoot } from "react-dom/client";
+import { createRoot, hydrateRoot } from "react-dom/client";
 import "../client/instrumentation-client.js";
 import { notifyAppRouterTransitionStart } from "../client/instrumentation-client-state.js";
 import {
@@ -1647,16 +1647,35 @@ function bootstrapHydration(rscStream: ReadableStream<Uint8Array>): void {
         onCaughtError: prodOnCaughtError,
         onUncaughtError,
       });
-  window.__VINEXT_RSC_ROOT__ = hydrateRootInTransition({
-    children: createElement(BrowserRoot, {
-      initialElements: root,
-      initialNavigationSnapshot,
-    }),
-    container: document,
-    hydrateRoot,
-    options: hydrateRootOptions,
-    startTransition,
+  const children = createElement(BrowserRoot, {
+    initialElements: root,
+    initialNavigationSnapshot,
   });
+  const errorShellStyles = document.querySelectorAll("style[data-vinext-error-shell-style]");
+  if (document.documentElement.id === "__next_error__") {
+    // Next.js client/app-index.tsx uses the document id alone to select CSR
+    // after any failed App Router server render. The style marker only scopes
+    // cleanup to vinext's shell-recovery placeholder styles.
+    // There is no server-rendered form to hydrate in this client-render path;
+    // reuse only the shared root error callbacks and related root options.
+    const { formState: _inertFormState, ...createRootOptions } = hydrateRootOptions;
+    for (const style of errorShellStyles) {
+      style.remove();
+    }
+    startTransition(() => {
+      const clientRoot = createRoot(document, createRootOptions);
+      clientRoot.render(children);
+      window.__VINEXT_RSC_ROOT__ = clientRoot;
+    });
+  } else {
+    window.__VINEXT_RSC_ROOT__ = hydrateRootInTransition({
+      children,
+      container: document,
+      hydrateRoot,
+      options: hydrateRootOptions,
+      startTransition,
+    });
+  }
   markInitialAppRouterBootstrapHydrated();
 
   const navigateRsc: NavigationRuntimeNavigate = async function navigateRsc(
@@ -2293,6 +2312,9 @@ function bootstrapHydration(rscStream: ReadableStream<Uint8Array>): void {
       // original document from there, so let the next HMR update reload the
       // current URL. If the edit fixed the error the page comes back clean; if
       // not, initial dev server errors re-populate the overlay.
+      //
+      // Reloading is safe for any default-error document because the dev
+      // server will render the current state of the source after the edit.
       if (document.documentElement.id === "__next_error__") {
         window.location.reload();
         return;
diff --git a/packages/vinext/src/server/app-page-boundary-render.ts b/packages/vinext/src/server/app-page-boundary-render.ts
index 24bab85cb..e29a3064f 100644
--- a/packages/vinext/src/server/app-page-boundary-render.ts
+++ b/packages/vinext/src/server/app-page-boundary-render.ts
@@ -24,6 +24,7 @@ import {
 } from "./app-page-stream.js";
 import { AppElementsWire, type AppElements } from "./app-elements.js";
 import { createAppPageLayoutEntries, createAppPageSourcePage } from "./app-page-route-wiring.js";
+import { NEVER_CACHE_CONTROL } from "./cache-control.js";
 
 // oxlint-disable-next-line @typescript-eslint/no-explicit-any
 type AppPageComponent = ComponentType<any>;
@@ -500,8 +501,8 @@ export async function renderAppPageErrorBoundary<TModule extends AppPageModule>(
     });
   };
 
-  const renderWith = (BoundaryComponent: AppPageComponent): Promise<Response> =>
-    renderAppPageBoundaryElementResponse({
+  const renderWith = async (BoundaryComponent: AppPageComponent): Promise<Response> => {
+    const response = await renderAppPageBoundaryElementResponse({
       ...options,
       element: buildElement(BoundaryComponent),
       initialDevServerError: rawError,
@@ -509,8 +510,16 @@ export async function renderAppPageErrorBoundary<TModule extends AppPageModule>(
       navigationParams: matchedParams,
       route: options.route,
       routePattern: options.route?.pattern,
-      status: 200,
+      status: errorBoundary.isGlobalError ? 500 : 200,
     });
+    if (errorBoundary.isGlobalError) {
+      response.headers.set("Cache-Control", NEVER_CACHE_CONTROL);
+      response.headers.delete("CDN-Cache-Control");
+      response.headers.delete("Cloudflare-CDN-Cache-Control");
+      response.headers.delete("Cache-Tag");
+    }
+    return response;
+  };
 
   try {
     return await renderWith(errorBoundary.component);
diff --git a/packages/vinext/src/server/app-page-dispatch.ts b/packages/vinext/src/server/app-page-dispatch.ts
index a453b1218..3a4b1918e 100644
--- a/packages/vinext/src/server/app-page-dispatch.ts
+++ b/packages/vinext/src/server/app-page-dispatch.ts
@@ -253,6 +253,7 @@ type DispatchAppPageOptions<TRoute extends AppPageDispatchRoute> = {
   getNavigationContext: () => NavigationContext | null;
   getSourceRoute: (sourceRouteIndex: number) => TRoute | undefined;
   hasGenerateStaticParams: boolean;
+  hasCustomGlobalError?: boolean;
   hasPageDefaultExport: boolean;
   hasPageModule: boolean;
   handlerStart: number;
@@ -1136,6 +1137,7 @@ async function dispatchAppPageInner<TRoute extends AppPageDispatchRoute>(
       return renderPageSpecialError(options, specialError);
     },
     renderToReadableStream: options.renderToReadableStream,
+    hasCustomGlobalError: options.hasCustomGlobalError,
     prerenderToReadableStream: options.prerenderToReadableStream,
     routePattern: route.pattern,
     runWithSuppressedHookWarning(probe) {
diff --git a/packages/vinext/src/server/app-page-render.ts b/packages/vinext/src/server/app-page-render.ts
index efd516478..6304ebcc0 100644
--- a/packages/vinext/src/server/app-page-render.ts
+++ b/packages/vinext/src/server/app-page-render.ts
@@ -57,7 +57,11 @@ import type {
   ClientReuseManifestSkipDisposition,
   ClientReuseManifestTraceFields,
 } from "./client-reuse-manifest.js";
-import { NO_STORE_CACHE_CONTROL } from "./cache-control.js";
+import {
+  applyCdnResponseHeaders,
+  NEVER_CACHE_CONTROL,
+  NO_STORE_CACHE_CONTROL,
+} from "./cache-control.js";
 import {
   createClientReuseSkipTransportPlan,
   createStaticLayoutClientReuseArtifactCompatibility,
@@ -127,6 +131,7 @@ type RenderAppPageLifecycleOptions = {
   peekRequestCacheLife?: () => AppPageRequestCacheLife | null;
   getDraftModeCookieHeader: () => string | null | undefined;
   handlerStart: number;
+  hasCustomGlobalError?: boolean;
   hasLoadingBoundary: boolean;
   dynamicStaleTimeSeconds?: number;
   isDynamicError: boolean;
@@ -868,6 +873,7 @@ export async function renderAppPageLifecycle(
       return renderAppPageHtmlStream({
         capturedRscDataRef,
         fontData,
+        hasCustomGlobalError: options.hasCustomGlobalError,
         navigationContext: options.getNavigationContext(),
         basePath: options.basePath,
         clientTraceMetadata: options.clientTraceMetadata,
@@ -975,6 +981,22 @@ export async function renderAppPageLifecycle(
     responseKind: "html",
   });
 
+  if (htmlRender.shellErrorRecovered) {
+    const response = buildAppPageHtmlResponse(safeHtmlStream, {
+      draftCookie,
+      linkHeader,
+      isEdgeRuntime: options.isEdgeRuntime,
+      middlewareContext: {
+        headers: options.middlewareContext.headers,
+        status: 500,
+      },
+      policy: { cacheControl: NEVER_CACHE_CONTROL },
+      timing: htmlResponseTiming,
+    });
+    applyCdnResponseHeaders(response.headers, { cacheControl: NEVER_CACHE_CONTROL });
+    return response;
+  }
+
   const shouldSpeculativelyWriteCache =
     options.isProduction &&
     shouldCaptureRscForCacheMetadata &&
diff --git a/packages/vinext/src/server/app-page-stream.ts b/packages/vinext/src/server/app-page-stream.ts
index 20bab031f..90eb10a57 100644
--- a/packages/vinext/src/server/app-page-stream.ts
+++ b/packages/vinext/src/server/app-page-stream.ts
@@ -22,6 +22,7 @@ export type AppSsrRenderResult = {
   htmlStream: ReadableStream<Uint8Array>;
   metadataReady: Promise<void>;
   capturedRscData: Promise<ArrayBuffer> | null;
+  shellErrorRecovered?: boolean;
   /**
    * Preload `Link` header value emitted by React during SSR (via `onHeaders`),
    * already capped to `reactMaxHeadersLength`. Empty/undefined when React
@@ -50,6 +51,7 @@ function normalizeAppSsrRenderResult(
     htmlStream: raw,
     metadataReady: resolvedMetadataReady,
     capturedRscData: fallbackCapturedRscData,
+    shellErrorRecovered: false,
   };
 }
 
@@ -134,6 +136,10 @@ export type AppPageSsrHandler = {
       waitForAllReady?: boolean;
       /** Dev-only: original server error to surface in the browser overlay. */
       initialDevServerError?: unknown;
+      /** When true, an SSR-phase-only shell render error resolves to the
+       *  default `__next_error__` error-document shell (with the original
+       *  flight payload and bootstrap) instead of rejecting. See handleSsr. */
+      fallbackToErrorDocumentOnShellError?: boolean;
     },
   ) => Promise<ReadableStream<Uint8Array> | AppSsrRenderResult>;
 };
@@ -170,6 +176,10 @@ type RenderAppPageHtmlStreamOptions = {
   waitForAllReady?: boolean;
   /** Dev-only: original server error to surface in the browser overlay. */
   initialDevServerError?: unknown;
+  /** True when the app supplies a custom global-error.tsx. Disables the
+   *  default error-document shell fallback so SSR shell errors keep driving
+   *  the server-rendered global-error boundary re-render. */
+  hasCustomGlobalError?: boolean;
 };
 
 type RenderAppPageHtmlResponseOptions = {
@@ -185,6 +195,7 @@ type AppPageHtmlStreamRecoveryResult = {
   response: Response | null;
   metadataReady: Promise<void>;
   capturedRscData: Promise<ArrayBuffer> | null;
+  shellErrorRecovered: boolean;
   /** React-emitted preload `Link` header (already capped). */
   linkHeader?: string;
 };
@@ -232,6 +243,10 @@ export async function renderAppPageHtmlStream(
     pprFallbackShellSignal: options.pprFallbackShellSignal,
     waitForAllReady: options.waitForAllReady,
     initialDevServerError: options.initialDevServerError,
+    // Only when the caller affirmatively knows there is no custom
+    // global-error.tsx; undefined (unknown) keeps reject semantics.
+    fallbackToErrorDocumentOnShellError:
+      options.waitForAllReady !== true && options.hasCustomGlobalError === false,
   };
 
   const rawResult = await options.ssrHandler.handleSsr(
@@ -336,7 +351,7 @@ export async function renderAppPageHtmlStreamWithRecovery<TSpecialError>(
 ): Promise<AppPageHtmlStreamRecoveryResult> {
   try {
     const rawResult = await options.renderHtmlStream();
-    const { htmlStream, metadataReady, capturedRscData, linkHeader } =
+    const { htmlStream, metadataReady, capturedRscData, linkHeader, shellErrorRecovered } =
       normalizeAppSsrRenderResult(rawResult);
     options.onShellRendered?.();
     return {
@@ -344,6 +359,7 @@ export async function renderAppPageHtmlStreamWithRecovery<TSpecialError>(
       response: null,
       metadataReady,
       capturedRscData,
+      shellErrorRecovered: shellErrorRecovered === true,
       linkHeader,
     };
   } catch (error) {
@@ -354,6 +370,7 @@ export async function renderAppPageHtmlStreamWithRecovery<TSpecialError>(
         response: await options.renderSpecialErrorResponse(specialError),
         metadataReady: resolvedMetadataReady,
         capturedRscData: null,
+        shellErrorRecovered: false,
       };
     }
 
@@ -364,6 +381,7 @@ export async function renderAppPageHtmlStreamWithRecovery<TSpecialError>(
         response: boundaryResponse,
         metadataReady: resolvedMetadataReady,
         capturedRscData: null,
+        shellErrorRecovered: false,
       };
     }
 
diff --git a/packages/vinext/src/server/app-ssr-entry.ts b/packages/vinext/src/server/app-ssr-entry.ts
index f29d31d46..4db0b541b 100644
--- a/packages/vinext/src/server/app-ssr-entry.ts
+++ b/packages/vinext/src/server/app-ssr-entry.ts
@@ -49,6 +49,7 @@ import { AppRouterContext } from "vinext/shims/internal/app-router-context";
 import { createClientReferencePreloader } from "./app-client-reference-preloader.js";
 import { RSC_FORM_STATE_GLOBAL } from "./app-browser-hydration.js";
 import { isPprFallbackShellAbortError } from "vinext/shims/ppr-fallback-shell";
+import DefaultGlobalError from "vinext/shims/default-global-error";
 import { appendAssetDeploymentIdQuery } from "../utils/deployment-id.js";
 
 /**
@@ -146,6 +147,49 @@ async function loadStaticPrerender(): Promise<StaticPrerender> {
   throw new Error("[vinext] react-dom/static.edge did not expose prerender().");
 }
 
+function createUtf8Stream(html: string): ReadableStream<Uint8Array> {
+  const encoder = new TextEncoder();
+  return new ReadableStream<Uint8Array>({
+    start(controller) {
+      controller.enqueue(encoder.encode(html));
+      controller.close();
+    },
+  });
+}
+
+function buildBootstrapModuleScript(bootstrapModuleUrl?: string, nonce?: string): string {
+  if (!bootstrapModuleUrl) return "";
+  return (
+    `<script type="module"${createNonceAttribute(nonce)} src="` +
+    escapeHtmlAttr(bootstrapModuleUrl) +
+    '" id="_R_" async=""></script>'
+  );
+}
+
+function renderSsrErrorDocumentShell(
+  bootstrapModuleUrl?: string,
+  nonce?: string,
+): ReadableStream<Uint8Array> {
+  const html = renderToStaticMarkup(
+    createReactElement(DefaultGlobalError, {
+      error: null,
+    }),
+  ).replace("<style>", '<style data-vinext-error-shell-style="">');
+  const bootstrapScript = buildBootstrapModuleScript(bootstrapModuleUrl, nonce);
+  if (!bootstrapScript) {
+    return createUtf8Stream(`<!DOCTYPE html>${html}`);
+  }
+
+  const documentClose = "</body></html>";
+  if (!html.endsWith(documentClose)) {
+    return createUtf8Stream(`<!DOCTYPE html>${html}${bootstrapScript}`);
+  }
+
+  return createUtf8Stream(
+    `<!DOCTYPE html>${html.slice(0, -documentClose.length)}${bootstrapScript}${documentClose}`,
+  );
+}
+
 const clientReferencePreloader = createClientReferencePreloader({
   getReferences() {
     return clientReferences;
@@ -376,6 +420,7 @@ export async function handleSsr(
      *  to resolve before returning the HTML stream. Used for static prerender
      *  and ISR cache writes to avoid caching fallback content. */
     waitForAllReady?: boolean;
+    fallbackToErrorDocumentOnShellError?: boolean;
   },
 ): Promise<AppSsrRenderResult> {
   return runWithNavigationContext(async () => {
@@ -584,6 +629,7 @@ export async function handleSsr(
         };
 
         let htmlStream: ReadableStream<Uint8Array>;
+        let shellErrorRecovered = false;
         if (pprFallbackShellSignal) {
           const prerender = await loadStaticPrerender();
           const htmlAbortController = new AbortController();
@@ -594,19 +640,29 @@ export async function handleSsr(
           setTimeout(() => htmlAbortController.abort(), 0);
           htmlStream = (await pendingHtml).prelude;
         } else {
-          const streamingHtmlStream = await renderToReadableStream(ssrRoot, {
-            ...renderOptions,
-          });
+          let streamingHtmlStream: Awaited<ReturnType<typeof renderToReadableStream>> | undefined;
+          try {
+            streamingHtmlStream = await renderToReadableStream(ssrRoot, {
+              ...renderOptions,
+            });
+
+            if (options?.waitForAllReady === true) {
+              await streamingHtmlStream.allReady;
+            }
 
-          // When producing static output (prerender / ISR cache writes), wait for
-          // the full React tree to resolve before emitting bytes. This prevents
-          // Suspense fallback content from being serialized to the cache.
-          // Matches Next.js waitForAllReady forkpoint in renderToNodeFizzStream.
-          if (options?.waitForAllReady === true) {
-            await streamingHtmlStream.allReady;
+            htmlStream = streamingHtmlStream;
+          } catch (error) {
+            void streamingHtmlStream?.cancel().catch(() => {});
+            if (
+              options?.fallbackToErrorDocumentOnShellError !== true ||
+              options?.waitForAllReady === true ||
+              typeof (error as { digest?: unknown } | null)?.digest === "string"
+            ) {
+              throw error;
+            }
+            shellErrorRecovered = true;
+            htmlStream = renderSsrErrorDocumentShell(bootstrapModuleUrl, options?.scriptNonce);
           }
-
-          htmlStream = streamingHtmlStream;
         }
 
         // Populated before any SSR request runs: at prod-server startup
@@ -693,6 +749,7 @@ export async function handleSsr(
           // this promise expecting it to be load-bearing in production.
           metadataReady: Promise.resolve(),
           capturedRscData: options?.capturedRscDataRef?.value ?? null,
+          shellErrorRecovered,
           linkHeader: reactLinkHeader,
         };
       } catch (error) {
diff --git a/packages/vinext/src/server/cache-control.ts b/packages/vinext/src/server/cache-control.ts
index 2444bda27..ead2a72fe 100644
--- a/packages/vinext/src/server/cache-control.ts
+++ b/packages/vinext/src/server/cache-control.ts
@@ -23,6 +23,10 @@ export function applyCdnResponseHeaders(headers: Headers, input: CdnCacheableHea
   headers.delete("Cache-Control");
   const map = getCdnCacheAdapter().buildResponseHeaders(input);
   for (const [name, value] of Object.entries(map)) {
+    if (value === null) {
+      headers.delete(name);
+      continue;
+    }
     // Never stamp an empty header. An adapter returns an empty `Cache-Control`
     // only when it has no default for an empty policy (e.g. the default
     // origin-managed adapter), in which case the header should stay absent
diff --git a/packages/vinext/src/shims/cdn-cache.ts b/packages/vinext/src/shims/cdn-cache.ts
index 727223f8b..c33ef6f05 100644
--- a/packages/vinext/src/shims/cdn-cache.ts
+++ b/packages/vinext/src/shims/cdn-cache.ts
@@ -36,8 +36,8 @@ import { getRequestExecutionContext } from "./request-context.js";
 // is present.
 import { CloudflareCdnCacheAdapter } from "@vinext/cloudflare/cache/cdn-adapter.runtime";
 
-/** A map of response header name -> value the adapter wants applied. */
-export type CdnResponseHeaders = Record<string, string>;
+/** A map of response header name -> value the adapter wants applied or removed. */
+export type CdnResponseHeaders = Record<string, string | null>;
 
 export type CdnCacheableHeaderInput = {
   /**
@@ -97,9 +97,9 @@ export type CdnCacheAdapter = {
   ): Promise<void>;
 
   /**
-   * Build the response cache headers for a given cacheable policy. Returns a map
-   * so an adapter can emit more than one header (e.g. `Cache-Control` +
-   * `CDN-Cache-Control`).
+   * Build the response cache headers for a given policy. Returns a map so an
+   * adapter can emit more than one header (e.g. `Cache-Control` +
+   * `CDN-Cache-Control`) and remove stale adapter-owned headers with `null`.
    */
   buildResponseHeaders(input: CdnCacheableHeaderInput): CdnResponseHeaders;
 
diff --git a/packages/vinext/src/utils/path.ts b/packages/vinext/src/utils/path.ts
index 49327f3ff..29384b3af 100644
--- a/packages/vinext/src/utils/path.ts
+++ b/packages/vinext/src/utils/path.ts
@@ -19,3 +19,12 @@ export function stripViteModuleQuery(id: string): string {
   const queryIndex = id.search(/[?#]/);
   return queryIndex === -1 ? id : id.slice(0, queryIndex);
 }
+
+/** Strip a trailing `.js` extension from a module specifier so
+ *  `resolveShimModulePath` looks for the correct base name (e.g. `headers.js`
+ *  → `headers`). Public and internal shim imports may carry extensionful
+ *  subpaths; normalising before resolution prevents looking for non-existent
+ *  files like `headers.js.ts`. */
+export function stripJsExtension(name: string): string {
+  return name.endsWith(".js") ? name.slice(0, -3) : name;
+}
diff --git a/tests/app-fallback-renderer.test.ts b/tests/app-fallback-renderer.test.ts
index 3c91852fe..1c2a3b8b0 100644
--- a/tests/app-fallback-renderer.test.ts
+++ b/tests/app-fallback-renderer.test.ts
@@ -413,7 +413,10 @@ describe("app fallback renderer default global error UI", () => {
       { headers: null, status: null },
     );
 
-    expect(response?.status).toBe(200);
+    expect(response?.status).toBe(500);
+    expect(response?.headers.get("cache-control")).toBe(
+      "private, no-cache, no-store, max-age=0, must-revalidate",
+    );
     const html = await response?.text();
 
     // 32x32 SVG warning icon (matches the test's `expect width/height === 32`).
@@ -455,7 +458,10 @@ describe("app fallback renderer default global error UI", () => {
       { headers: null, status: null },
     );
 
-    expect(response?.status).toBe(200);
+    expect(response?.status).toBe(500);
+    expect(response?.headers.get("cache-control")).toBe(
+      "private, no-cache, no-store, max-age=0, must-revalidate",
+    );
     const html = await response?.text();
     // Server errors still render the same heading.
     expect(html).toContain("This page couldn’t load");
diff --git a/tests/app-page-boundary-render.test.ts b/tests/app-page-boundary-render.test.ts
index 6e484d884..5a90db2b8 100644
--- a/tests/app-page-boundary-render.test.ts
+++ b/tests/app-page-boundary-render.test.ts
@@ -652,7 +652,10 @@ describe("app page boundary render helpers", () => {
       },
     });
 
-    expect(response?.status).toBe(200);
+    expect(response?.status).toBe(500);
+    expect(response?.headers.get("cache-control")).toBe(
+      "private, no-cache, no-store, max-age=0, must-revalidate",
+    );
 
     const html = await response?.text();
     expect(html).toContain('data-boundary="global-error"');
@@ -666,7 +669,7 @@ describe("app page boundary render helpers", () => {
     // When the resolved global-error boundary itself throws while rendering, the
     // SSR render rejects; renderAppPageErrorBoundary catches it and re-renders
     // with the built-in default global-error so the request still produces a
-    // usable document (HTTP 200) instead of a raw 500. Locks in the server-side
+    // usable error document with the original HTTP 500 semantics. Locks in the server-side
     // retry directly (the integration test in tests/nextjs-compat/global-error
     // exercises the same path through the dev/preview server). Fixes #1548.
     const common = createCommonOptions();
@@ -686,7 +689,10 @@ describe("app page boundary render helpers", () => {
       },
     });
 
-    expect(response?.status).toBe(200);
+    expect(response?.status).toBe(500);
+    expect(response?.headers.get("cache-control")).toBe(
+      "private, no-cache, no-store, max-age=0, must-revalidate",
+    );
 
     const html = await response?.text();
     // The built-in default global-error UI from
diff --git a/tests/app-page-dispatch.test.ts b/tests/app-page-dispatch.test.ts
index 403e7ae38..df1d65b82 100644
--- a/tests/app-page-dispatch.test.ts
+++ b/tests/app-page-dispatch.test.ts
@@ -266,6 +266,7 @@ type CreateDispatchOptionsOverrides = {
   dynamicConfig?: DispatchOptions["dynamicConfig"];
   findIntercept?: DispatchOptions["findIntercept"];
   generateStaticParams?: DispatchOptions["generateStaticParams"];
+  hasCustomGlobalError?: DispatchOptions["hasCustomGlobalError"];
   formState?: DispatchOptions["formState"];
   getSourceRoute?: DispatchOptions["getSourceRoute"];
   getNavigationContext?: DispatchOptions["getNavigationContext"];
@@ -344,6 +345,7 @@ function createDispatchOptions(overrides: CreateDispatchOptionsOverrides = {}) {
       })),
     getSourceRoute: overrides.getSourceRoute ?? (() => undefined),
     hasGenerateStaticParams: typeof overrides.generateStaticParams === "function",
+    hasCustomGlobalError: overrides.hasCustomGlobalError,
     hasPageDefaultExport: true,
     hasPageModule: true,
     handlerStart: 10,
@@ -1371,6 +1373,7 @@ describe("app page dispatch", () => {
       scheduledRender = renderFn;
     };
     let capturedWaitForAllReady: boolean | undefined;
+    let capturedFallbackToErrorDocument: boolean | undefined;
     const isrSet = vi.fn(async () => {});
     const { options } = createDispatchOptions({
       buildPageElement: async () => React.createElement("main", null, "fresh"),
@@ -1380,9 +1383,11 @@ describe("app page dispatch", () => {
         buildISRCacheEntry(buildCachedAppPageValue("<html>stale</html>"), true),
       ),
       isrSet,
+      hasCustomGlobalError: false,
       loadSsrHandler: async () => ({
         async handleSsr(_rscStream, _navigationContext, _fontData, captureOptions) {
           capturedWaitForAllReady = captureOptions?.waitForAllReady;
+          capturedFallbackToErrorDocument = captureOptions?.fallbackToErrorDocumentOnShellError;
           if (captureOptions?.capturedRscDataRef) {
             captureOptions.capturedRscDataRef.value = Promise.resolve(
               new TextEncoder().encode("fresh-flight").buffer,
@@ -1412,9 +1417,55 @@ describe("app page dispatch", () => {
     await scheduledRender();
 
     expect(capturedWaitForAllReady).toBe(true);
+    expect(capturedFallbackToErrorDocument).toBeUndefined();
     expect(isrSet).toHaveBeenCalled();
   });
 
+  it("preserves stale HTML when SSR shell rendering fails during regeneration", async () => {
+    const route = createRoute({ pattern: "/posts/[slug]", routeSegments: ["posts", "[slug]"] });
+    let scheduledRender: unknown = null;
+    const scheduleBackgroundRegeneration: DispatchOptions["scheduleBackgroundRegeneration"] = (
+      _key,
+      renderFn,
+    ) => {
+      scheduledRender = renderFn;
+    };
+    const isrSet = vi.fn(async () => {});
+    const shellError = new Error("SSR shell failed");
+    const { options } = createDispatchOptions({
+      buildPageElement: async () => React.createElement("main", null, "fresh"),
+      cleanPathname: "/posts/hello",
+      isProduction: true,
+      isrGet: vi.fn(async () =>
+        buildISRCacheEntry(buildCachedAppPageValue("<html>stale</html>"), true),
+      ),
+      isrSet,
+      loadSsrHandler: async () => ({
+        async handleSsr() {
+          throw shellError;
+        },
+      }),
+      renderToReadableStream() {
+        return createStream(["flight"]);
+      },
+      revalidateSeconds: 60,
+      route,
+      scheduleBackgroundRegeneration,
+    });
+
+    const response = await dispatchAppPage(options);
+
+    expect(response.headers.get("x-vinext-cache")).toBe("STALE");
+    await expect(response.text()).resolves.toBe("<html>stale</html>");
+    expect(typeof scheduledRender).toBe("function");
+    if (typeof scheduledRender !== "function") {
+      throw new Error("expected stale HTML response to schedule regeneration");
+    }
+
+    await expect(scheduledRender()).rejects.toBe(shellError);
+    expect(isrSet).not.toHaveBeenCalled();
+  });
+
   it("resolves the revalidation target route's dynamic config for force-dynamic fetch defaults", async () => {
     // When regenerating a stale cache entry for a target route that is force-dynamic,
     // the dispatch must resolve the target route's dynamic config so that fetch
diff --git a/tests/app-page-render.test.ts b/tests/app-page-render.test.ts
index 3646cf86f..d2be6920d 100644
--- a/tests/app-page-render.test.ts
+++ b/tests/app-page-render.test.ts
@@ -29,11 +29,16 @@ import {
 } from "../packages/vinext/src/server/client-reuse-manifest.js";
 import { VINEXT_DYNAMIC_STALE_TIME_HEADER } from "../packages/vinext/src/server/headers.js";
 import type { CachedAppPageValue } from "../packages/vinext/src/shims/cache.js";
+import {
+  DefaultCdnCacheAdapter,
+  setCdnCacheAdapter,
+} from "../packages/vinext/src/shims/cdn-cache.js";
 import { markDynamicUsage } from "../packages/vinext/src/shims/headers.js";
 import {
   createRequestContext,
   runWithRequestContext,
 } from "../packages/vinext/src/shims/unified-request-context.js";
+import { CloudflareCdnCacheAdapter } from "../packages/cloudflare/src/cache/cdn-adapter.runtime.js";
 
 function captureRecord(value: ReactNode | AppOutgoingElements): Record<string, unknown> {
   if (!isAppElementsRecord(value)) {
@@ -323,6 +328,51 @@ describe("clearRequestContext timing — issue #660", () => {
   });
 });
 
+describe("SSR shell error recovery", () => {
+  it("returns an uncached 500 response for a recovered dynamic shell error", async () => {
+    setCdnCacheAdapter(new CloudflareCdnCacheAdapter());
+    const common = createCommonOptions();
+    try {
+      const response = await renderAppPageLifecycle({
+        ...common.options,
+        isProduction: true,
+        middlewareContext: {
+          headers: new Headers({
+            "Cache-Control": "public, max-age=3600",
+            "CDN-Cache-Control": "public, max-age=3600",
+            "Cloudflare-CDN-Cache-Control": "public, max-age=3600",
+            "Cache-Tag": "shell-error",
+          }),
+          status: null,
+        },
+        revalidateSeconds: 30,
+        loadSsrHandler: async () => ({
+          async handleSsr() {
+            return {
+              htmlStream: createStream(['<html id="__next_error__"></html>']),
+              metadataReady: Promise.resolve(),
+              capturedRscData: null,
+              shellErrorRecovered: true,
+            };
+          },
+        }),
+      });
+
+      expect(response.status).toBe(500);
+      expect(response.headers.get("cache-control")).toBe(
+        "private, no-cache, no-store, max-age=0, must-revalidate",
+      );
+      expect(response.headers.get("cdn-cache-control")).toBeNull();
+      expect(response.headers.get("cloudflare-cdn-cache-control")).toBeNull();
+      expect(response.headers.get("cache-tag")).toBeNull();
+      await expect(response.text()).resolves.toContain("__next_error__");
+      expect(common.isrSet).not.toHaveBeenCalled();
+    } finally {
+      setCdnCacheAdapter(new DefaultCdnCacheAdapter());
+    }
+  });
+});
+
 describe("form state rendering", () => {
   it("passes action form state to SSR and disables HTML cache writes", async () => {
     const common = createCommonOptions();
diff --git a/tests/app-page-stream.test.ts b/tests/app-page-stream.test.ts
index 3519a20f9..254c091ff 100644
--- a/tests/app-page-stream.test.ts
+++ b/tests/app-page-stream.test.ts
@@ -313,9 +313,35 @@ describe("app page stream helpers", () => {
 
     expect(onShellRendered).toHaveBeenCalledTimes(1);
     expect(result.response).toBeNull();
+    expect(result.shellErrorRecovered).toBe(false);
     await expect(new Response(result.htmlStream).text()).resolves.toBe("<html>ok</html>");
   });
 
+  it("preserves the SSR shell recovery outcome", async () => {
+    const result = await renderAppPageHtmlStreamWithRecovery({
+      async renderErrorBoundaryResponse() {
+        throw new Error("should not render an error boundary");
+      },
+      async renderHtmlStream() {
+        return {
+          htmlStream: createStream(['<html id="__next_error__"></html>']),
+          metadataReady: Promise.resolve(),
+          capturedRscData: null,
+          shellErrorRecovered: true,
+        };
+      },
+      async renderSpecialErrorResponse() {
+        throw new Error("should not render a special response");
+      },
+      resolveSpecialError() {
+        return null;
+      },
+    });
+
+    expect(result.response).toBeNull();
+    expect(result.shellErrorRecovered).toBe(true);
+  });
+
   it("turns special SSR failures into the provided response", async () => {
     const ssrError = new Error("redirect");
     const renderSpecialErrorResponse = vi.fn(async () => new Response("special", { status: 307 }));
diff --git a/tests/app-router-dev-server.test.ts b/tests/app-router-dev-server.test.ts
index e35ac2486..d5900f338 100644
--- a/tests/app-router-dev-server.test.ts
+++ b/tests/app-router-dev-server.test.ts
@@ -1151,7 +1151,7 @@ describe("App Router integration", () => {
   // instead of silently returning a fallback value.
   it("errors when client hook is used in a Server Component without 'use client' (#834)", async () => {
     const { res, html } = await fetchHtml(baseUrl, "/missing-use-client-test");
-    expect(res.status).toBe(200); // error boundary renders, not a 500
+    expect(res.status).toBe(500);
     // The error message should be clear and actionable
     expect(html).toContain("usePathname()");
     expect(html).toContain("Client Components");
@@ -1162,7 +1162,7 @@ describe("App Router integration", () => {
 
   it("errors when React client hook is used in a Server Component without 'use client' (#834)", async () => {
     const { res, html } = await fetchHtml(baseUrl, "/missing-use-client-react-hook");
-    expect(res.status).toBe(200); // error boundary renders, not a 500
+    expect(res.status).toBe(500);
     // The error message should be clear and actionable
     expect(html).toContain("useState()");
     expect(html).toContain("Client Components");
@@ -1852,7 +1852,7 @@ describe("App Router integration", () => {
 
   it("applies dynamic = 'error' as only-cache fetch policy", async () => {
     const res = await fetch(`${baseUrl}/layout-segment-config/dynamic-error-fetch`);
-    expect(res.status).toBe(200);
+    expect(res.status).toBe(500);
     expect(await res.text()).toContain("only-cache");
   });
 
diff --git a/tests/cache-control.test.ts b/tests/cache-control.test.ts
index 17a11d35b..5348549f1 100644
--- a/tests/cache-control.test.ts
+++ b/tests/cache-control.test.ts
@@ -93,6 +93,36 @@ describe("applyCdnResponseHeaders", () => {
     expect(headers.get("Cache-Tag")).toBe("a,b");
   });
 
+  it("applies adapter-owned header removals", () => {
+    const edge: CdnCacheAdapter = {
+      ownsBackgroundRevalidation: false,
+      async get() {
+        return null;
+      },
+      async set() {},
+      buildResponseHeaders() {
+        return {
+          "Cache-Control": "no-store",
+          "CDN-Cache-Control": null,
+          "Cache-Tag": null,
+        };
+      },
+      async revalidateTag() {},
+    };
+    setCdnCacheAdapter(edge);
+
+    const headers = new Headers({
+      "Cache-Control": "public, max-age=3600",
+      "CDN-Cache-Control": "public, max-age=3600",
+      "Cache-Tag": "stale",
+    });
+    applyCdnResponseHeaders(headers, { cacheControl: "no-store" });
+
+    expect(headers.get("Cache-Control")).toBe("no-store");
+    expect(headers.get("CDN-Cache-Control")).toBeNull();
+    expect(headers.get("Cache-Tag")).toBeNull();
+  });
+
   it("default adapter restores baseline after the edge adapter is cleared", () => {
     setCdnCacheAdapter(new DefaultCdnCacheAdapter());
     const headers = new Headers();
diff --git a/tests/cloudflare-cdn-cache.test.ts b/tests/cloudflare-cdn-cache.test.ts
index eae2ed95b..6b6774c6e 100644
--- a/tests/cloudflare-cdn-cache.test.ts
+++ b/tests/cloudflare-cdn-cache.test.ts
@@ -98,9 +98,12 @@ describe("CloudflareCdnCacheAdapter", () => {
       "private, no-cache, no-store, max-age=0, must-revalidate",
     ]) {
       const headers = adapter.buildResponseHeaders({ cacheControl: cc, tags: ["x"] });
-      expect(headers).toEqual({ "Cache-Control": cc });
-      expect(headers["CDN-Cache-Control"]).toBeUndefined();
-      expect(headers["Cache-Tag"]).toBeUndefined();
+      expect(headers).toEqual({
+        "Cache-Control": cc,
+        "CDN-Cache-Control": null,
+        "Cloudflare-CDN-Cache-Control": null,
+        "Cache-Tag": null,
+      });
     }
   });
 
diff --git a/tests/e2e/app-router/nextjs-compat/ssr-error-shell-recovery.browser.spec.ts b/tests/e2e/app-router/nextjs-compat/ssr-error-shell-recovery.browser.spec.ts
new file mode 100644
index 000000000..7ac167e70
--- /dev/null
+++ b/tests/e2e/app-router/nextjs-compat/ssr-error-shell-recovery.browser.spec.ts
@@ -0,0 +1,353 @@
+/**
+ * SSR shell-error recovery in production builds.
+ *
+ * When the HTML (Fizz) render of an SSR pass rejects with an error that did
+ * not originate in the RSC render (no `digest`), and the app has no custom
+ * global-error.tsx, vinext serves the default `__next_error__` error-document
+ * shell with the original flight payload and bootstrap module. The browser
+ * detects the marker and re-renders the real tree with `createRoot` instead
+ * of hydrating — Next.js's shell-error recovery semantics:
+ * https://github.com/vercel/next.js/blob/v16.2.6/packages/next/src/server/app-render/app-render.tsx
+ *
+ * The throw-during-SSR-only pattern ("Expected error to opt out of server
+ * rendering") comes from the Next.js `next-dynamic-css` fixture:
+ * https://github.com/vercel/next.js/blob/v16.2.6/test/e2e/app-dir/next-dynamic-css/next-dynamic-css.test.ts
+ *
+ * This fixture intentionally has NO custom global-error.tsx — that is the
+ * configuration in which handleSsr's error-document fallback is active
+ * (`fallbackToErrorDocumentOnShellError`). Apps with a custom global-error
+ * keep the server-rendered boundary re-render path, covered by
+ * tests/nextjs-compat/global-error.test.ts.
+ */
+import fs from "node:fs/promises";
+import type { Server } from "node:http";
+import os from "node:os";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { expect, test } from "../../fixtures";
+
+type ProductionApp = {
+  baseUrl: string;
+  fixtureRoot: string;
+  server: Server;
+};
+
+async function closeServer(server: Server): Promise<void> {
+  const closed = new Promise<void>((resolve) => server.close(() => resolve()));
+  server.closeIdleConnections();
+  server.closeAllConnections();
+  await closed;
+}
+
+async function linkFixtureNodeModules(fixtureRoot: string): Promise<void> {
+  const sourceNodeModules = path.resolve(process.cwd(), "tests/fixtures/app-basic/node_modules");
+  const targetNodeModules = path.join(fixtureRoot, "node_modules");
+
+  await fs.mkdir(targetNodeModules, { recursive: true });
+
+  for (const entry of await fs.readdir(sourceNodeModules, { withFileTypes: true })) {
+    if (entry.name === ".vite-temp") continue;
+
+    await fs.symlink(
+      path.join(sourceNodeModules, entry.name),
+      path.join(targetNodeModules, entry.name),
+      entry.isDirectory() ? "junction" : "file",
+    );
+  }
+}
+
+async function writeRecoveryFixture(fixtureRoot: string): Promise<void> {
+  const appDir = path.join(fixtureRoot, "app");
+  await fs.mkdir(appDir, { recursive: true });
+  await fs.mkdir(path.join(fixtureRoot, "public"), { recursive: true });
+  await linkFixtureNodeModules(fixtureRoot);
+
+  // Minimal valid .ico so browser favicon requests do not 404 (the console
+  // error fixture is strict).
+  await fs.writeFile(
+    path.join(fixtureRoot, "public/favicon.ico"),
+    new Uint8Array([
+      0, 0, 1, 0, 1, 0, 1, 1, 0, 0, 1, 0, 32, 0, 48, 0, 0, 0, 22, 0, 0, 0, 40, 0, 0, 0, 1, 0, 0, 0,
+      2, 0, 0, 0, 1, 0, 32, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 255, 255, 255, 0,
+    ]),
+  );
+
+  await fs.writeFile(
+    path.join(fixtureRoot, "package.json"),
+    `${JSON.stringify({ type: "module", dependencies: {} }, null, 2)}\n`,
+  );
+  await fs.writeFile(
+    path.join(appDir, "layout.tsx"),
+    `import { ReactNode } from "react";
+
+export default function Root({ children }: { children: ReactNode }) {
+  return (
+    <html>
+      <body>{children}</body>
+    </html>
+  );
+}
+`,
+  );
+
+  // No local boundary: an SSR-only client throw rejects the HTML shell and the
+  // default __next_error__ document recovery re-renders the real tree in the
+  // browser. `cookies()` keeps the page dynamic so the runtime SSR pass (not a
+  // prerendered document) serves the request.
+  const pageDir = path.join(appDir, "page");
+  await fs.mkdir(pageDir, { recursive: true });
+  await fs.writeFile(
+    path.join(pageDir, "page.tsx"),
+    `import React from "react";
+import { cookies } from "next/headers";
+import Client from "./Client";
+
+export default async function Page() {
+  await cookies();
+  return (
+    <>
+      <p id="server-content">Hello Server</p>
+      <Client />
+    </>
+  );
+}
+`,
+  );
+  await fs.writeFile(
+    path.join(pageDir, "Client.tsx"),
+    `"use client";
+import React from "react";
+
+export default function Client() {
+  if (typeof window === "undefined") {
+    throw new Error("Expected error to opt out of server rendering");
+  }
+  return <p id="client-content">Hello Client</p>;
+}
+`,
+  );
+
+  // Genuine RSC/server error with no custom global-error.tsx. It also uses an
+  // __next_error__ document, but must retain the pre-existing hydration path
+  // rather than being mistaken for the marked SSR shell-recovery document.
+  const serverErrorDir = path.join(appDir, "server-error");
+  await fs.mkdir(serverErrorDir, { recursive: true });
+  await fs.writeFile(
+    path.join(serverErrorDir, "page.tsx"),
+    `export default function ServerErrorPage(): never {
+  throw new Error("genuine server digest error");
+}
+`,
+  );
+
+  // Local error.tsx routes: the shell fallback must not swallow local
+  // boundary semantics. Local boundaries for shell errors materialize
+  // client-side from the flight payload (Next.js parity):
+  // - /boundary-ssr-only: the SSR render error remains represented in the
+  //   initial tree, so the local boundary handles it after client rendering.
+  // - /boundary-always: the browser re-render throws again and React catches
+  //   it in the local error.tsx delivered in the flight payload.
+  const boundarySsrOnlyDir = path.join(appDir, "boundary-ssr-only");
+  const boundaryAlwaysDir = path.join(appDir, "boundary-always");
+  await fs.mkdir(boundarySsrOnlyDir, { recursive: true });
+  await fs.mkdir(boundaryAlwaysDir, { recursive: true });
+
+  const localErrorBoundary = `"use client";
+import React from "react";
+export default function LocalError() {
+  return <p id="local-error-boundary">Local boundary caught it</p>;
+}
+`;
+
+  await fs.writeFile(
+    path.join(boundarySsrOnlyDir, "page.tsx"),
+    `import React from "react";
+import { cookies } from "next/headers";
+import Client from "./Client";
+export default async function BoundarySsrOnlyPage() {
+  await cookies();
+  return <Client />;
+}
+`,
+  );
+  await fs.writeFile(
+    path.join(boundarySsrOnlyDir, "Client.tsx"),
+    `"use client";
+import React from "react";
+export default function Client() {
+  if (typeof window === "undefined") {
+    throw new Error("ssr-only boundary throw");
+  }
+  return <p id="boundary-ssr-only-content">Recovered client render</p>;
+}
+`,
+  );
+  await fs.writeFile(path.join(boundarySsrOnlyDir, "error.tsx"), localErrorBoundary);
+
+  await fs.writeFile(
+    path.join(boundaryAlwaysDir, "page.tsx"),
+    `import React from "react";
+import { cookies } from "next/headers";
+import Client from "./Client";
+export default async function BoundaryAlwaysPage() {
+  await cookies();
+  return <Client />;
+}
+`,
+  );
+  await fs.writeFile(
+    path.join(boundaryAlwaysDir, "Client.tsx"),
+    `"use client";
+import React from "react";
+export default function Client(): React.ReactNode {
+  throw new Error("always boundary throw");
+}
+`,
+  );
+  await fs.writeFile(path.join(boundaryAlwaysDir, "error.tsx"), localErrorBoundary);
+
+  // Ported from Next.js default global-error client runtime semantics:
+  // https://github.com/vercel/next.js/blob/canary/test/e2e/app-dir/errors/index.test.ts
+  // Combined with the SSR shell-recovery entry path exercised by:
+  // https://github.com/vercel/next.js/blob/canary/test/e2e/app-dir/next-dynamic-css/next-dynamic-css.test.ts
+  const noBoundaryAlwaysDir = path.join(appDir, "no-boundary-always");
+  await fs.mkdir(noBoundaryAlwaysDir, { recursive: true });
+  await fs.writeFile(
+    path.join(noBoundaryAlwaysDir, "page.tsx"),
+    `import React from "react";
+import { cookies } from "next/headers";
+import Client from "./Client";
+export default async function NoBoundaryAlwaysPage() {
+  await cookies();
+  return <Client />;
+}
+`,
+  );
+  await fs.writeFile(
+    path.join(noBoundaryAlwaysDir, "Client.tsx"),
+    `"use client";
+import React from "react";
+export default function Client(): React.ReactNode {
+  throw new Error("always no boundary throw");
+}
+`,
+  );
+
+  const vinextSource = path.resolve(process.cwd(), "packages/vinext/src/index.ts");
+  await fs.writeFile(
+    path.join(fixtureRoot, "vite.config.ts"),
+    `import { defineConfig } from "vite";
+import vinext from ${JSON.stringify(pathToFileURL(vinextSource).href)};
+
+export default defineConfig({
+  plugins: [vinext({ appDir: import.meta.dirname })],
+});
+`,
+  );
+}
+
+async function buildPrerenderAndServeRecoveryFixture(): Promise<ProductionApp> {
+  const fixtureRoot = await fs.mkdtemp(path.join(os.tmpdir(), "vinext-ssr-error-recovery-"));
+  await writeRecoveryFixture(fixtureRoot);
+
+  const { createBuilder } = await import("vite");
+  const builder = await createBuilder({
+    root: fixtureRoot,
+    configFile: path.join(fixtureRoot, "vite.config.ts"),
+    logLevel: "silent",
+  });
+  await builder.buildApp();
+
+  const { runPrerender } = await import(
+    pathToFileURL(path.resolve(process.cwd(), "packages/vinext/dist/build/run-prerender.js")).href
+  );
+  await runPrerender({ root: fixtureRoot });
+
+  const { startProdServer } = await import(
+    pathToFileURL(path.resolve(process.cwd(), "packages/vinext/dist/server/prod-server.js")).href
+  );
+  const started = await startProdServer({
+    host: "127.0.0.1",
+    port: 0,
+    outDir: path.join(fixtureRoot, "dist"),
+    noCompression: true,
+  });
+
+  return {
+    baseUrl: `http://127.0.0.1:${started.port}`,
+    fixtureRoot,
+    server: started.server,
+  };
+}
+
+test.setTimeout(90_000);
+
+test.describe("SSR shell-error recovery (no custom global-error.tsx)", () => {
+  test("recovers the real tree in the browser and preserves local error.tsx semantics", async ({
+    page,
+    consoleErrors,
+  }) => {
+    const app = await buildPrerenderAndServeRecoveryFixture();
+
+    try {
+      // SSR-only client throw without a boundary: the default __next_error__
+      // shell is served and the browser re-renders the real tree from the
+      // embedded flight payload.
+      await page.goto(`${app.baseUrl}/page`, { waitUntil: "load" });
+      await expect(page.locator("#server-content")).toHaveText("Hello Server");
+      await expect(page.locator("#client-content")).toHaveText("Hello Client");
+
+      // A genuine server/RSC error also uses the default __next_error__
+      // document and follows Next.js's createRoot recovery path. Unlike the
+      // SSR-only recovery shell, it has no placeholder style marker to remove.
+      await page.goto(`${app.baseUrl}/server-error`, { waitUntil: "load" });
+      await expect(page.getByRole("heading", { name: "This page couldn’t load" })).toBeVisible();
+      await expect(page.getByText("Reload to try again, or go back.")).toBeVisible();
+      await expect(page.getByRole("button", { name: "Reload" })).toBeVisible();
+      await expect(page.getByRole("button", { name: "Back" })).toBeVisible();
+      await expect(page.locator("style[data-vinext-error-shell-style]")).toHaveCount(0);
+
+      // SSR-only throw with a local error.tsx: the error remains represented
+      // in the initial tree and the local boundary provides the visible UX.
+      await page.goto(`${app.baseUrl}/boundary-ssr-only`, { waitUntil: "load" });
+      await expect(page.locator("#local-error-boundary")).toHaveText("Local boundary caught it");
+      await expect(page.locator("#boundary-ssr-only-content")).toHaveCount(0);
+
+      // Unconditional client throw: the browser re-render throws again and the
+      // local error.tsx from the flight payload catches it.
+      await page.goto(`${app.baseUrl}/boundary-always`, { waitUntil: "load" });
+      await expect(page.locator("#local-error-boundary")).toHaveText("Local boundary caught it");
+
+      // No local boundary: the shell recovery still re-renders on the client,
+      // but the root default global-error boundary must catch the repeated
+      // throw instead of leaving a blank torn-down document.
+      await page.goto(`${app.baseUrl}/no-boundary-always`, { waitUntil: "load" });
+      await expect(page.getByRole("heading", { name: "This page couldn’t load" })).toBeVisible();
+      await expect(page.getByText("Reload to try again, or go back.")).toBeVisible();
+      await expect(page.getByRole("button", { name: "Reload" })).toBeVisible();
+      await expect(page.getByRole("button", { name: "Back" })).toBeVisible();
+
+      // The boundary routes throw on purpose, and React logs caught boundary
+      // errors to the console. Drop those expected entries but stay strict
+      // about anything else; the fixture re-asserts emptiness at teardown.
+      const unexpectedErrors = consoleErrors.filter(
+        (message) =>
+          !message.includes("boundary throw") &&
+          !message.includes("always no boundary throw") &&
+          !message.includes("genuine server digest error") &&
+          !message.includes("Expected error to opt out of server rendering") &&
+          // The recovery and global-error documents intentionally preserve
+          // their HTTP 500 status, which browsers report as a resource error.
+          !message.includes("Failed to load resource: the server responded with a status of 500") &&
+          // React's companion log for an error caught by a boundary.
+          !message.startsWith("The above error occurred in a React component"),
+      );
+      expect(unexpectedErrors).toEqual([]);
+      consoleErrors.length = 0;
+    } finally {
+      await closeServer(app.server);
+      await fs.rm(app.fixtureRoot, { recursive: true, force: true });
+    }
+  });
+});
diff --git a/tests/nextjs-compat/global-error.test.ts b/tests/nextjs-compat/global-error.test.ts
index 760fef786..7be5022cc 100644
--- a/tests/nextjs-compat/global-error.test.ts
+++ b/tests/nextjs-compat/global-error.test.ts
@@ -85,10 +85,13 @@ describe("Next.js compat: global-error", () => {
 
   it("server component throw without local error.tsx renders global-error", async () => {
     // global-error-rsc/page.tsx throws "server page error" with no error.tsx.
-    // Next.js renders global-error.tsx and returns 200 (the boundary "handles" it).
+    // Next.js renders global-error.tsx with a 500 status for an unhandled error.
     // Source: index.test.ts#L29-L49
     const { res, html } = await fetchHtml(baseUrl, "/nextjs-compat/global-error-rsc");
-    expect(res.status).toBe(200);
+    expect(res.status).toBe(500);
+    expect(res.headers.get("cache-control")).toBe(
+      "private, no-cache, no-store, max-age=0, must-revalidate",
+    );
     expect(html).toContain("global-error");
     expect(html).toContain("server page error");
   });
@@ -103,7 +106,10 @@ describe("Next.js compat: global-error", () => {
     // "use client" component throws during SSR. Next.js renders global-error.tsx.
     // Source: index.test.ts#L51-L66
     const { res, html } = await fetchHtml(baseUrl, "/nextjs-compat/global-error-ssr");
-    expect(res.status).toBe(200);
+    expect(res.status).toBe(500);
+    expect(res.headers.get("cache-control")).toBe(
+      "private, no-cache, no-store, max-age=0, must-revalidate",
+    );
     expect(html).toContain("global-error");
     expect(html).toContain("client page error");
   });
@@ -131,13 +137,13 @@ describe("Next.js compat: global-error", () => {
 
   it("generateMetadata() error without local boundary renders global-error", async () => {
     // generateMetadata() throws, no local error.tsx — escalates to global-error.tsx.
-    // Next.js returns 200 with global-error rendered.
+    // Next.js returns 500 with global-error rendered.
     // Source: index.test.ts#L75-L93
     const { res, html } = await fetchHtml(
       baseUrl,
       "/nextjs-compat/metadata-error-without-boundary",
     );
-    expect(res.status).toBe(200);
+    expect(res.status).toBe(500);
     expect(html).toContain("global-error");
     expect(html).toContain("Metadata error");
   });
@@ -161,7 +167,7 @@ describe("Next.js compat: global-error", () => {
       baseUrl,
       "/nextjs-compat/layout-metadata-error-without-boundary",
     );
-    expect(res.status).toBe(200);
+    expect(res.status).toBe(500);
     expect(html).toContain("global-error");
     expect(html).toContain("Layout metadata error");
   });
@@ -185,7 +191,7 @@ describe("Next.js compat: global-error", () => {
       baseUrl,
       "/nextjs-compat/layout-viewport-error-without-boundary",
     );
-    expect(res.status).toBe(200);
+    expect(res.status).toBe(500);
     expect(html).toContain("global-error");
     expect(html).toContain("Layout viewport error");
   });
@@ -207,7 +213,7 @@ describe("Next.js compat: global-error", () => {
 
   it("self-throwing global-error renders the built-in default fallback", async () => {
     const { res, html } = await fetchHtml(baseUrl, "/nextjs-compat/global-error-self-throw");
-    expect(res.status).toBe(200);
+    expect(res.status).toBe(500);
     // The built-in default global-error UI from
     // packages/vinext/src/shims/default-global-error.tsx.
     expect(html).toContain("This page couldn");
@@ -298,17 +304,17 @@ describe("Next.js compat: global-error (production preview)", () => {
     fs.rmSync(outDir, { recursive: true, force: true });
   });
 
-  it("server component throw without local error.tsx renders global-error with 200", async () => {
+  it("server component throw without local error.tsx renders global-error with 500", async () => {
     const { res, html } = await fetchHtml(baseUrl, "/nextjs-compat/global-error-rsc");
-    expect(res.status).toBe(200);
+    expect(res.status).toBe(500);
     expect(html).toContain("global-error");
     expect(html).toContain("The specific message is omitted in production builds");
     expect(html).not.toContain("server page error");
   });
 
-  it("client component SSR throw without local error.tsx renders global-error with 200", async () => {
+  it("client component SSR throw without local error.tsx renders global-error with 500", async () => {
     const { res, html } = await fetchHtml(baseUrl, "/nextjs-compat/global-error-ssr");
-    expect(res.status).toBe(200);
+    expect(res.status).toBe(500);
     expect(html).toContain("global-error");
     expect(html).toContain("The specific message is omitted in production builds");
     expect(html).not.toContain("client page error");
@@ -335,12 +341,12 @@ describe("Next.js compat: global-error (production preview)", () => {
     expect(html).not.toContain("global-error");
   });
 
-  it("generateMetadata() errors without a local boundary escalate to global-error with 200", async () => {
+  it("generateMetadata() errors without a local boundary escalate to global-error with 500", async () => {
     const { res, html } = await fetchHtml(
       baseUrl,
       "/nextjs-compat/metadata-error-without-boundary",
     );
-    expect(res.status).toBe(200);
+    expect(res.status).toBe(500);
     expect(html).toContain("global-error");
   });
 
@@ -354,12 +360,12 @@ describe("Next.js compat: global-error (production preview)", () => {
     expect(html).not.toContain("global-error");
   });
 
-  it("layout generateMetadata() errors without a local boundary escalate to global-error with 200", async () => {
+  it("layout generateMetadata() errors without a local boundary escalate to global-error with 500", async () => {
     const { res, html } = await fetchHtml(
       baseUrl,
       "/nextjs-compat/layout-metadata-error-without-boundary",
     );
-    expect(res.status).toBe(200);
+    expect(res.status).toBe(500);
     expect(html).toContain("global-error");
   });
 
@@ -373,18 +379,18 @@ describe("Next.js compat: global-error (production preview)", () => {
     expect(html).not.toContain("global-error");
   });
 
-  it("layout generateViewport() errors without a local boundary escalate to global-error with 200", async () => {
+  it("layout generateViewport() errors without a local boundary escalate to global-error with 500", async () => {
     const { res, html } = await fetchHtml(
       baseUrl,
       "/nextjs-compat/layout-viewport-error-without-boundary",
     );
-    expect(res.status).toBe(200);
+    expect(res.status).toBe(500);
     expect(html).toContain("global-error");
   });
 
-  it("self-throwing global-error renders the built-in default fallback with 200", async () => {
+  it("self-throwing global-error renders the built-in default fallback with 500", async () => {
     const { res, html } = await fetchHtml(baseUrl, "/nextjs-compat/global-error-self-throw");
-    expect(res.status).toBe(200);
+    expect(res.status).toBe(500);
     expect(html).toContain("This page couldn");
     expect(html).toContain("load");
     expect(html).not.toContain("Something went wrong!");
diff --git a/tests/shims.test.ts b/tests/shims.test.ts
index 7745104cb..379667d72 100644
--- a/tests/shims.test.ts
+++ b/tests/shims.test.ts
@@ -20416,6 +20416,53 @@ describe("@vercel/og compatibility resolution", () => {
   });
 });
 
+describe("vinext shim package-subpath resolution", () => {
+  type ResolveIdHook = {
+    filter: { id: RegExp };
+    handler: (
+      this: { environment?: { name?: string } },
+      id: string,
+      importer?: string,
+    ) => string | undefined;
+  };
+
+  function getResolveIdHook(): ResolveIdHook {
+    const plugins = vinext() as Plugin[];
+    const configPlugin = plugins.find((plugin) => plugin.name === "vinext:config");
+    if (!configPlugin?.resolveId || typeof configPlugin.resolveId === "function") {
+      throw new Error("vinext:config resolveId hook not found");
+    }
+    return configPlugin.resolveId as ResolveIdHook;
+  }
+
+  it("strips JavaScript extensions and Vite queries from package subpaths", () => {
+    const hook = getResolveIdHook();
+    const expectedShim = path.resolve(
+      import.meta.dirname,
+      "../packages/vinext/src/shims/navigation.ts",
+    );
+    const expectedReactServerShim = path.resolve(
+      import.meta.dirname,
+      "../packages/vinext/src/shims/navigation.react-server.ts",
+    );
+    const expectedOgShim = path.resolve(import.meta.dirname, "../packages/vinext/src/shims/og.tsx");
+
+    expect(hook.filter.id.test("vinext/shims/navigation.js?v=123")).toBe(true);
+    expect(hook.filter.id.test("\0vinext/shims/navigation.js?v=123")).toBe(true);
+    expect(hook.filter.id.test("\0next/navigation")).toBe(true);
+    expect(hook.filter.id.test("\0@vercel/og")).toBe(true);
+    expect(hook.handler.call({}, "unrelated-next/navigation")).toBeUndefined();
+    expect(hook.handler.call({}, "vinext/shims/navigation.js?v=123")).toBe(expectedShim);
+    expect(hook.handler.call({}, "\0vinext/shims/navigation.js?v=123")).toBe(expectedShim);
+    expect(hook.handler.call({ environment: { name: "rsc" } }, "\0next/navigation")).toBe(
+      expectedReactServerShim,
+    );
+    expect(
+      hook.handler.call({}, "\0@vercel/og", path.join(FIXTURE_DIR, "app/opengraph-image.tsx")),
+    ).toBe(expectedOgShim);
+  });
+});
+
 // ── next/head attribute name validation ─────────────────────────────────────
 
 describe("isSafeAttrName", () => {