vinext 1.0.1 → 1.2.0

package/README.md

@@ -147,6 +147,9 @@ Other options: `--port <port>` (default: 3001), `--skip-check`, `--force`.
 Cloudflare init uses `cf` and `cloudflare.config.ts` by default. Both `vinext init`
 and `create-vinext-app` accept `--legacy-wrangler-cloudflare-init` to retain the
 legacy Wrangler setup. Existing Wrangler configs are not automatically migrated.
+`vinext init --name <name>` sets the Worker name in the generated config instead of
+deriving it from `package.json`. An existing config keeps its own Worker name, and init
+prints a warning.
 
 If your `next.config.*` sets `output: "standalone"`, `vite build` emits a self-hosting bundle at `dist/standalone/`. Start it with:
 
@@ -158,6 +161,42 @@ Environment variables: `PORT` (default `3000`), `HOST` (default `0.0.0.0`).
 
 > **Note:** Next.js standalone uses `HOSTNAME` for the bind address, but vinext uses `HOST` to avoid collision with the system-set `HOSTNAME` variable on Linux. Update your deployment config accordingly.
 
+#### Custom standalone entries
+
+The generated `server.js` is a small wrapper around `startProdServer` from `vinext/server/prod-server`. To control where the server loads the build output from, write your own entry and call `startProdServer` directly. All options are optional:
+
+| Option            | Default                                        | Description                                                                                                                                                            |
+| ----------------- | ---------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `port`            | `PORT` env var, otherwise `3000`               | Port to listen on.                                                                                                                                                     |
+| `host`            | `"0.0.0.0"`                                    | Address to bind to. Unlike the generated `server.js`, `startProdServer` doesn't read `HOST`, so pass `process.env.HOST` yourself if you need it.                       |
+| `outDir`          | `dist`, resolved against the current directory | Build output directory containing `client/` and `server/`. Relative paths resolve against the current directory. In standalone output, this is `dist/standalone/dist`. |
+| `serverDir`       | `<outDir>/server`                              | Directory containing the server bundles, manifests, and prerendered output.                                                                                            |
+| `rscEntryPath`    | `<serverDir>/index.js`                         | App Router server entry. If this file exists, the server runs in App Router mode.                                                                                      |
+| `serverEntryPath` | `<serverDir>/entry.js`                         | Pages Router server entry. Used when there's no App Router entry.                                                                                                      |
+| `noCompression`   | `false`                                        | Disable response compression.                                                                                                                                          |
+
+`ProdServerOptions` also has `purpose` and `silent`, which vinext uses for its own build-time servers. Leave them unset. The returned promise resolves to `{ server, port }` once the server is listening.
+
+**Compiled single-file binaries.** A `bun build --compile` binary can't use the generated `server.js`. Bun fixes `import.meta.dirname` when it compiles the binary, so `join(import.meta.dirname, "dist")` doesn't point at the directory the binary runs from. Depending on the Bun version, it points at the build machine's path or at Bun's embedded `/$bunfs/root`. Resolve `outDir` from the executable's location instead:
+
+```js
+// server-bin.mjs, in your project root
+import path from "node:path";
+import { startProdServer } from "vinext/server/prod-server";
+
+await startProdServer({
+  port: Number.parseInt(process.env.PORT ?? "3000", 10),
+  host: process.env.HOST ?? "0.0.0.0",
+  outDir: path.join(path.dirname(process.execPath), "dist"),
+});
+```
+
+```bash
+bun build --compile --compile-autoload-package-json server-bin.mjs --outfile dist/standalone/server
+```
+
+Keep the entry outside `dist/standalone`: each build deletes and recreates that directory. Compile after `vite build`, then ship the whole `dist/standalone` directory, because the `server` binary needs the `dist/` and `node_modules/` directories next to it. The server bundles in `dist/server` still import their dependencies from `node_modules` at runtime. `--compile-autoload-package-json` lets the binary read package `exports` and `main` fields when it resolves them. Under plain Node, `process.execPath` is the Node binary, so use this entry only for compiled builds.
+
 ### Starting a new vinext project
 
 Use `create-vinext-app` for new projects. It creates a TypeScript App Router project
@@ -246,7 +285,7 @@ You can, with caution. vinext has known compatibility gaps and has not yet been
 Yes. Next.js supports [self-hosting](https://nextjs.org/docs/app/building-your-application/deploying#self-hosting) on Node.js servers, Docker containers, and static exports. If you're happy with the Next.js toolchain and just want to run it somewhere other than Vercel, self-hosting is the simplest path.
 
 **How are you verifying this works?**
-The test suite has over 1,700 Vitest tests and 380 Playwright E2E tests. This includes tests ported directly from the [Next.js test suite](https://github.com/vercel/next.js/tree/canary/test) and [OpenNext's Cloudflare conformance suite](https://github.com/opennextjs/opennextjs-cloudflare), covering routing, SSR, RSC, server actions, caching, metadata, middleware, streaming, and more. Vercel's [App Router Playground](https://github.com/vercel/next-app-router-playground) also runs on vinext as an integration test. See the [Tests](#tests) section and `tests/nextjs-compat/TRACKING.md` for details.
+The test suite has over 1,700 Vitest tests and 380 Playwright E2E tests. This includes tests ported directly from the [Next.js test suite](https://github.com/vercel/next.js/tree/canary/test) and [OpenNext's Cloudflare conformance suite](https://github.com/opennextjs/opennextjs-cloudflare), covering routing, SSR, RSC, server actions, caching, metadata, middleware, streaming, and more. Vercel's [App Router Playground](https://github.com/vercel/next-app-router-playground) also runs on vinext as an integration test. See the [Tests](#tests) section for details.
 
 **Who is reviewing this code?**
 A mix of humans and AI agents. Humans review PRs before they merge, focused on behavior, structure, and long-term direction. We lean heavily on agent-driven code review to catch issues at PR time and across the codebase. The test suite is the primary quality gate. Outside contributions and deeper human code review are very welcome.
@@ -401,10 +440,14 @@ export default defineConfig({
 
 #### Module Federation (client-side)
 
-For client-side Module Federation, configure React and React DOM as singleton shared modules in both the host and remotes:
+Use [`@module-federation/vinext`](https://github.com/module-federation/vinext), a thin wrapper around `@module-federation/vite` with vinext defaults. Register `federation()` before `vinext()`:
+
+```bash
+npm install @module-federation/vinext
+```
 
 ```ts
-import { federation } from "@module-federation/vite";
+import { federation } from "@module-federation/vinext";
 import { defineConfig } from "vite";
 import vinext from "vinext";
 
@@ -412,11 +455,14 @@ export default defineConfig({
   plugins: [
     federation({
       name: "host",
-      shared: {
-        react: { singleton: true },
-        "react/": { singleton: true },
-        "react-dom": { singleton: true },
-        "react-dom/": { singleton: true },
+      remotes: {
+        catalog: {
+          type: "module",
+          name: "catalog",
+          entry: "https://catalog.example.com/remoteEntry.js",
+          entryGlobalName: "catalog",
+          shareScope: "default",
+        },
       },
     }),
     vinext(),
@@ -424,6 +470,8 @@ export default defineConfig({
 });
 ```
 
+The wrapper shares `react` and `react-dom` as singletons, defaults `filename` to `remoteEntry.js`, and injects the host's federation startup into the entry, because vinext has no conventional HTML entry. Explicit options override these defaults, and every `@module-federation/vite` option remains available. Passing your own `shared` replaces the default map, so keep `react`, `react/`, `react-dom`, and `react-dom/` as singletons in it, in both the host and remotes.
+
 In a remote client component, use `getVinextReact()` before reading React hooks. vinext registers the host's browser React instance before application modules execute, and the first registration remains stable across remote evaluation and HMR:
 
 ```tsx
@@ -442,7 +490,7 @@ export function RemoteCounter() {
 
 This bridge is browser-only. It does not provide App Router Module Federation SSR or transparently replace React imports inside third-party packages; compatible React versions remain the responsibility of the Module Federation `shared` configuration.
 
-See the [examples](#live-examples) for complete working configurations.
+See the [Module Federation guide](https://vinext.dev/docs/guides/module-federation) for loading remote components in the host.
 
 ### Other platforms (via Nitro)
 
@@ -792,7 +840,7 @@ their `env` binding lookups) are instantiated lazily on the first request.
 
 Registration is wired into **every router and runtime** — App Router and Pages Router, on Cloudflare Workers as well as the Node.js server (`vinext start`) and dev. It self-guards (instantiated once per isolate) and is resilient: if an adapter can't initialize on a given runtime (e.g. a KV binding doesn't exist on the Node server), vinext logs a warning and falls back to the default handler instead of failing requests.
 
-To write your own adapter, point a slot at any module by path and default-export a factory that receives `{ env, options }` at runtime and returns a data-cache `CacheHandler` (or a CDN adapter):
+To write your own adapter, point a slot at any module by path. Its default export receives one `{ env, options }` argument at runtime and produces a data-cache `CacheHandler` (or a CDN adapter):
 
 ```ts
 vinext({
@@ -805,6 +853,41 @@ vinext({
 });
 ```
 
+The default export can be a factory or a class:
+
+```ts
+// my-adapter.js: a factory
+export default ({ env, options }) => ({
+  async get(key) {
+    /* … */
+  },
+  async set(key, data) {
+    /* … */
+  },
+  async revalidateTag(tags) {
+    /* … */
+  },
+});
+
+// my-adapter.js: or a class
+export default class MyAdapter {
+  constructor({ env, options }) {
+    /* … */
+  }
+  async get(key) {
+    /* … */
+  }
+  async set(key, data) {
+    /* … */
+  }
+  async revalidateTag(tags) {
+    /* … */
+  }
+}
+```
+
+vinext invokes class syntax with `new` and calls any other function, so existing factories keep plain-call semantics. A constructor that isn't class syntax (an ES5-compiled, bound, or Proxy-wrapped class) can't be told apart from a factory, so export a factory that constructs it: `export default (args) => new MyAdapter(args)`. The result must be the adapter itself, not a Promise. A data adapter implements `get`, `set`, and `revalidateTag`; a CDN adapter also implements `buildResponseHeaders` and sets `ownsBackgroundRevalidation` to a boolean. If the export isn't a function or the result is missing a member, vinext logs a warning naming the slot and what's wrong, then keeps the default handler.
+
 ## What's NOT supported (and won't be)
 
 These are intentional exclusions. For things that are missing today but on the roadmap, see [Known gaps we're working on](#known-gaps-were-working-on) above.

package/dist/build/app-page-static-eligibility.d.ts

@@ -0,0 +1,15 @@
+import { AppRoute } from "../routing/app-route-graph.js";
+//#region src/build/app-page-static-eligibility.d.ts
+/**
+ * Whether Next.js classifies an App page route as static or SSG, read from its
+ * layout, page and parallel-slot sources with the helpers dispatch applies to
+ * the loaded modules. Only such a route has listed paths.
+ *
+ * An MDX source read without the MDX parser has unknown exports, so its route
+ * is "unreadable". Its paths are still listed: the built runtime reads the real
+ * exports and never stores a route that isn't static, while an unlisted path's
+ * render failure would be dropped instead of failing. But no probe renders an
+ * unreadable route's fallback, so it never certifies one.
+ */
+export declare function classifyAppPageRouteStaticEligibility(route: AppRoute, readMdxEsm: ((source: string) => string) | null): "eligible" | "ineligible" | "unreadable";
+//#endregion

package/dist/build/app-page-static-eligibility.js

@@ -0,0 +1,82 @@
+import { extractExportConstNumber, extractExportConstString, hasRuntimeExportedName } from "./report.js";
+import { collectAppPageStaticGenerationRuntimes, hasAppPageGenerateStaticParamsAtLastDynamicSegment, isAppPageStaticEligible, isEdgeRuntime, resolveAppPageSegmentConfig, resolveAppPageStaticGenerationRuntime } from "../server/app-segment-config.js";
+import fs from "node:fs";
+//#region src/build/app-page-static-eligibility.ts
+/**
+* Whether Next.js classifies an App page route as static or SSG, read from its
+* layout, page and parallel-slot sources with the helpers dispatch applies to
+* the loaded modules. Only such a route has listed paths.
+*
+* An MDX source read without the MDX parser has unknown exports, so its route
+* is "unreadable". Its paths are still listed: the built runtime reads the real
+* exports and never stores a route that isn't static, while an unlisted path's
+* render failure would be dropped instead of failing. But no probe renders an
+* unreadable route's fallback, so it never certifies one.
+*/
+function classifyAppPageRouteStaticEligibility(route, readMdxEsm) {
+	let unreadable = false;
+	const readSegmentConfig = (filePath) => {
+		if (!filePath) return null;
+		let code = fs.readFileSync(filePath, "utf8");
+		if (filePath.toLowerCase().endsWith(".mdx")) {
+			let esm = null;
+			try {
+				esm = readMdxEsm?.(code) ?? null;
+			} catch {}
+			unreadable ||= esm === null;
+			code = esm ?? "";
+		}
+		const dynamic = extractExportConstString(code, "dynamic");
+		const revalidate = extractExportConstNumber(code, "revalidate");
+		const runtime = extractExportConstString(code, "runtime");
+		return {
+			...dynamic === null ? {} : { dynamic },
+			...hasRuntimeExportedName(code, "generateStaticParams") ? { generateStaticParams() {} } : {},
+			...revalidate === null ? {} : { revalidate },
+			...runtime === null ? {} : { runtime }
+		};
+	};
+	const layouts = route.layouts.map(readSegmentConfig);
+	const page = readSegmentConfig(route.pagePath);
+	const parallelBranches = route.parallelSlots.map((slot) => ({
+		configLayouts: (slot.configLayoutPaths ?? []).map(readSegmentConfig),
+		configLayoutTreePositions: slot.configLayoutTreePositions ?? [],
+		isDefault: !slot.pagePath,
+		layout: readSegmentConfig(slot.layoutPath),
+		name: slot.name,
+		ownerTreePosition: slot.ownerTreePosition ?? null,
+		page: readSegmentConfig(slot.pagePath ?? slot.defaultPath),
+		routeSegments: slot.routeSegments
+	}));
+	if (unreadable) return "unreadable";
+	const segmentConfig = resolveAppPageSegmentConfig({
+		layouts,
+		layoutTreePositions: route.layoutTreePositions,
+		page,
+		parallelBranches,
+		routeSegments: route.routeSegments
+	});
+	return isAppPageStaticEligible({
+		dynamicConfig: segmentConfig.dynamicConfig,
+		hasGenerateStaticParams: hasAppPageGenerateStaticParamsAtLastDynamicSegment({
+			childrenSlot: route.childrenSlot ?? null,
+			layouts,
+			layoutTreePositions: route.layoutTreePositions,
+			page,
+			parallelBranches,
+			routeSegments: route.routeSegments
+		}),
+		isDynamicRoute: route.isDynamic,
+		isStaticGenerationEdgeRuntime: isEdgeRuntime(resolveAppPageStaticGenerationRuntime(collectAppPageStaticGenerationRuntimes({
+			childrenSlot: route.childrenSlot ?? null,
+			layouts,
+			layoutTreePositions: route.layoutTreePositions,
+			page,
+			parallelBranches,
+			routeSegments: route.routeSegments
+		}))),
+		revalidateSeconds: segmentConfig.revalidateSeconds
+	}) ? "eligible" : "ineligible";
+}
+//#endregion
+export { classifyAppPageRouteStaticEligibility };

package/dist/build/client-build-config.d.ts

@@ -116,4 +116,14 @@ export declare function createMultiStageCodeSplittingConfig(existing: VinextBuil
  * the host's existing output pattern (or vinext's server-assets default).
  */
 export declare function createMultiStageChunkFileNames(assetsDir: string, existing: VinextBuildOutput["chunkFileNames"]): ChunkFileNameFunction;
+/**
+ * The client environment builds after RSC and SSR, and Vite empties its
+ * output directory first. A client output directory that is, or contains, a
+ * server output directory would therefore delete the server build.
+ */
+export declare function assertClientOutDirIsSeparate(root: string, dirs: {
+  clientOutDir?: string;
+  rscOutDir?: string;
+  ssrOutDir?: string;
+}): void;
 //#endregion

package/dist/build/client-build-config.js

@@ -1,6 +1,7 @@
-import { toSlash } from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
+import path, { toSlash } from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 //#region src/build/client-build-config.ts
 const ROUTE_OWNED_CLIENT_SHIMS = /* @__PURE__ */ new Set([
+	"app-router-tree-context",
 	"compat-router",
 	"dynamic",
 	"dynamic-preload-chunks",
@@ -266,5 +267,20 @@ function createMultiStageChunkFileNames(assetsDir, existing) {
 		return (existing ?? joinAssetFileNamePattern(assetsDir, "[name]-[hash].js")).replaceAll("[name]", name);
 	};
 }
+/**
+* The client environment builds after RSC and SSR, and Vite empties its
+* output directory first. A client output directory that is, or contains, a
+* server output directory would therefore delete the server build.
+*/
+function assertClientOutDirIsSeparate(root, dirs) {
+	if (!dirs.clientOutDir) return;
+	const clientOutDir = path.resolve(root, dirs.clientOutDir);
+	const serverOutDirs = [["rscOutDir", dirs.rscOutDir ?? "dist/server"], ["ssrOutDir", dirs.ssrOutDir ?? "dist/server/ssr"]];
+	for (const [name, dir] of serverOutDirs) {
+		const relative = path.relative(clientOutDir, path.resolve(root, dir));
+		if (relative === ".." || relative.startsWith("../") || path.isAbsolute(relative)) continue;
+		throw new Error(`[vinext] clientOutDir "${dirs.clientOutDir}" contains ${name} "${dir}". The client build runs last and empties its output directory, which would delete the server build. Use separate output directories.`);
+	}
+}
 //#endregion
-export { RSC_FRAMEWORK_CHUNK_TEST, createClientAssetFileNames, createClientCodeSplittingConfig, createClientFileNameConfig, createClientManualChunks, createMultiStageChunkFileNames, createMultiStageCodeSplittingConfig, createRscFrameworkChunkOutputConfig, getBuildBundlerOptions, getClientTreeshakeConfig, isRscFrameworkModule, sanitizeRscChunkFileName, withBuildBundlerOptions };
+export { RSC_FRAMEWORK_CHUNK_TEST, assertClientOutDirIsSeparate, createClientAssetFileNames, createClientCodeSplittingConfig, createClientFileNameConfig, createClientManualChunks, createMultiStageChunkFileNames, createMultiStageCodeSplittingConfig, createRscFrameworkChunkOutputConfig, getBuildBundlerOptions, getClientTreeshakeConfig, isRscFrameworkModule, sanitizeRscChunkFileName, withBuildBundlerOptions };

package/dist/build/pages-client-assets-module.d.ts

@@ -2,5 +2,13 @@ import { PagesClientAssets } from "../server/pages-client-assets.js";
 //#region src/build/pages-client-assets-module.d.ts
 export declare const PAGES_CLIENT_ASSETS_MODULE = "vinext-client-assets.js";
 export declare function buildPagesClientAssetsModule(assets: PagesClientAssets): string;
+/**
+ * Select the client bundle files that live outside `_next/static`, as URL
+ * pathnames. Plugins emit these at the output root, for example a Module
+ * Federation host's `remoteEntry.js`. Public directory files are copied
+ * outside the bundle, and build metadata (vinext's and Cloudflare's
+ * `.assetsignore`) is excluded.
+ */
+export declare function collectClientBuildFiles(fileNames: Iterable<string>): string[];
 export declare function writePagesClientAssetsModuleIfMissing(outputDir: string, moduleSource: string): void;
 //#endregion

package/dist/build/pages-client-assets-module.js

@@ -1,5 +1,7 @@
 import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
+import "../utils/asset-prefix.js";
 import { getSharedChunkFiles } from "../server/pages-asset-tags.js";
+import "../utils/client-entry-manifest.js";
 import fs from "node:fs";
 //#region src/build/pages-client-assets-module.ts
 const PAGES_CLIENT_ASSETS_MODULE = "vinext-client-assets.js";
@@ -10,6 +12,24 @@ function buildPagesClientAssetsModule(assets) {
 	} : assets;
 	return `export default ${JSON.stringify(prepared)};\n`;
 }
+/**
+* Select the client bundle files that live outside `_next/static`, as URL
+* pathnames. Plugins emit these at the output root, for example a Module
+* Federation host's `remoteEntry.js`. Public directory files are copied
+* outside the bundle, and build metadata (vinext's and Cloudflare's
+* `.assetsignore`) is excluded.
+*/
+function collectClientBuildFiles(fileNames) {
+	const files = [];
+	for (const fileName of fileNames) {
+		const pathname = `/${fileName}`;
+		if (pathname.includes(`/_next/static/`)) continue;
+		if (pathname.startsWith("/.vite/") || fileName === "vinext-client-entry-manifest.json") continue;
+		if (fileName === ".assetsignore") continue;
+		files.push(pathname);
+	}
+	return files.sort();
+}
 function writePagesClientAssetsModuleIfMissing(outputDir, moduleSource) {
 	const outputPath = path.join(outputDir, PAGES_CLIENT_ASSETS_MODULE);
 	if (fs.existsSync(outputPath)) return;
@@ -17,4 +37,4 @@ function writePagesClientAssetsModuleIfMissing(outputDir, moduleSource) {
 	fs.writeFileSync(outputPath, moduleSource);
 }
 //#endregion
-export { PAGES_CLIENT_ASSETS_MODULE, buildPagesClientAssetsModule, writePagesClientAssetsModuleIfMissing };
+export { PAGES_CLIENT_ASSETS_MODULE, buildPagesClientAssetsModule, collectClientBuildFiles, writePagesClientAssetsModuleIfMissing };

package/dist/build/prerender-paths.js

@@ -10,17 +10,18 @@ import { apiRouter, matchRoute, pagesRouter } from "../routing/pages-router.js";
 import "../server/headers.js";
 import { matchesMiddlewarePathname } from "../server/middleware-matcher.js";
 import { extractLocaleFromUrl, normalizeDefaultLocalePathname } from "../server/pages-i18n.js";
-import { classifyAppRoute, classifyAppRouteHandler, classifyPagesRoute, extractExportConstNumber, extractExportConstString, extractMiddlewareMatcherConfig, getAppRouteRenderEntryPath, hasRuntimeExportedName } from "./report.js";
+import { classifyAppRoute, classifyAppRouteHandler, classifyPagesRoute, extractExportConstString, extractMiddlewareMatcherConfig, getAppRouteRenderEntryPath } from "./report.js";
 import { normalizeStaticPathname, normalizeStaticPathsEntry } from "../routing/route-pattern.js";
 import { buildPagesDataHref } from "../shims/internal/pages-data-url.js";
 import { normalizePathTrailingSlash } from "../shims/url-utils.js";
+import { resolveAppPageDynamicConfig } from "../server/app-segment-config.js";
+import { classifyAppPageRouteStaticEligibility } from "./app-page-static-eligibility.js";
 import { pagesRouteHasPriorityOverAppRoute } from "../server/hybrid-route-priority.js";
 import { readPrerenderSecret } from "./server-manifest.js";
 import { loadMdxEsmReader } from "../utils/mdx-scan.js";
 import { startProdServer } from "../server/prod-server.js";
 import { enterPrerenderPhase } from "./prerender-phase.js";
 import { buildUrlFromParams, layoutOnlyParamSets, localizePagesPath, resolveParentParams, routeStaticParamSets, validateDiscoveredParams } from "./prerender.js";
-import { collectAppPageStaticGenerationRuntimes, hasAppPageGenerateStaticParamsAtLastDynamicSegment, isAppPageStaticEligible, isEdgeRuntime, resolveAppPageDynamicConfig, resolveAppPageSegmentConfig, resolveAppPageStaticGenerationRuntime } from "../server/app-segment-config.js";
 import { resolveBuiltPagesEntryPath, resolveBuiltRscEntryPath } from "./server-entry.js";
 import fs from "node:fs";
 //#region src/build/prerender-paths.ts
@@ -133,6 +134,7 @@ async function fetchDiscoveryEndpoint(url, headers, retryOptions = {}) {
 			const request = (async () => {
 				const res = await fetch(url, {
 					headers,
+					redirect: "manual",
 					signal: controller.signal
 				});
 				return {
@@ -151,10 +153,11 @@ async function fetchDiscoveryEndpoint(url, headers, retryOptions = {}) {
 				if (res.status === 204) return null;
 				return text;
 			}
-			const userFailure = readDiscoveryUserFailure(res, text);
+			const redirected = res.status >= 300 && res.status < 400;
+			const userFailure = redirected ? null : readDiscoveryUserFailure(res, text);
 			const detail = userFailure ?? (/cloudflare:|ERR_UNSUPPORTED_ESM_URL_SCHEME/i.test(text) ? text.trim() : "");
-			lastError = /* @__PURE__ */ new Error(`path discovery returned HTTP ${res.status}${detail ? `: ${detail}` : ""}`);
-			if (!(res.status === 404 || res.status >= 500 && res.status <= 599 && userFailure === null)) {
+			lastError = redirected ? /* @__PURE__ */ new Error(`path discovery returned a redirect (HTTP ${res.status}); refusing to follow it with the prerender secret`) : /* @__PURE__ */ new Error(`path discovery returned HTTP ${res.status}${detail ? `: ${detail}` : ""}`);
+			if (!(redirected || res.status === 404 || res.status >= 500 && res.status <= 599 && userFailure === null)) {
 				shouldRetry = false;
 				throw lastError;
 			}
@@ -351,82 +354,6 @@ function extractPagesStaticPathLocale(url, i18n) {
 		url: `${rest || "/"}${query}`
 	};
 }
-/**
-* Whether Next.js classifies an App page route as static or SSG, read from its
-* layout, page and parallel-slot sources with the helpers dispatch applies to
-* the loaded modules. Only such a route has listed paths.
-*
-* An MDX source read without the MDX parser has unknown exports, so its route
-* is "unreadable". Its paths are still listed: the built runtime reads the real
-* exports and never stores a route that isn't static, while an unlisted path's
-* render failure would be dropped instead of failing. But no probe renders an
-* unreadable route's fallback, so it never certifies one.
-*/
-function classifyAppPageRouteStaticEligibility(route, readMdxEsm) {
-	let unreadable = false;
-	const readSegmentConfig = (filePath) => {
-		if (!filePath) return null;
-		let code = fs.readFileSync(filePath, "utf8");
-		if (filePath.toLowerCase().endsWith(".mdx")) {
-			let esm = null;
-			try {
-				esm = readMdxEsm?.(code) ?? null;
-			} catch {}
-			unreadable ||= esm === null;
-			code = esm ?? "";
-		}
-		const dynamic = extractExportConstString(code, "dynamic");
-		const revalidate = extractExportConstNumber(code, "revalidate");
-		const runtime = extractExportConstString(code, "runtime");
-		return {
-			...dynamic === null ? {} : { dynamic },
-			...hasRuntimeExportedName(code, "generateStaticParams") ? { generateStaticParams() {} } : {},
-			...revalidate === null ? {} : { revalidate },
-			...runtime === null ? {} : { runtime }
-		};
-	};
-	const layouts = route.layouts.map(readSegmentConfig);
-	const page = readSegmentConfig(route.pagePath);
-	const parallelBranches = route.parallelSlots.map((slot) => ({
-		configLayouts: (slot.configLayoutPaths ?? []).map(readSegmentConfig),
-		configLayoutTreePositions: slot.configLayoutTreePositions ?? [],
-		isDefault: !slot.pagePath,
-		layout: readSegmentConfig(slot.layoutPath),
-		name: slot.name,
-		ownerTreePosition: slot.ownerTreePosition ?? null,
-		page: readSegmentConfig(slot.pagePath ?? slot.defaultPath),
-		routeSegments: slot.routeSegments
-	}));
-	if (unreadable) return "unreadable";
-	const segmentConfig = resolveAppPageSegmentConfig({
-		layouts,
-		layoutTreePositions: route.layoutTreePositions,
-		page,
-		parallelBranches,
-		routeSegments: route.routeSegments
-	});
-	return isAppPageStaticEligible({
-		dynamicConfig: segmentConfig.dynamicConfig,
-		hasGenerateStaticParams: hasAppPageGenerateStaticParamsAtLastDynamicSegment({
-			childrenSlot: route.childrenSlot ?? null,
-			layouts,
-			layoutTreePositions: route.layoutTreePositions,
-			page,
-			parallelBranches,
-			routeSegments: route.routeSegments
-		}),
-		isDynamicRoute: route.isDynamic,
-		isStaticGenerationEdgeRuntime: isEdgeRuntime(resolveAppPageStaticGenerationRuntime(collectAppPageStaticGenerationRuntimes({
-			childrenSlot: route.childrenSlot ?? null,
-			layouts,
-			layoutTreePositions: route.layoutTreePositions,
-			page,
-			parallelBranches,
-			routeSegments: route.routeSegments
-		}))),
-		revalidateSeconds: segmentConfig.revalidateSeconds
-	}) ? "eligible" : "ineligible";
-}
 /** Keys a path an App page route lists by the route and the pathname together. */
 function appPageListingKey(routePattern, pathname) {
 	return `${routePattern}\0${pathname}`;

package/dist/build/prerender.js

@@ -4,7 +4,7 @@ import { isUnknownRecord } from "../utils/record.js";
 import { BLOCKED_PAGES } from "../shims/constants.js";
 import { VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, VINEXT_PRERENDER_SECRET_HEADER, VINEXT_PRERENDER_SPECULATIVE_HEADER } from "../utils/protocol-headers.js";
 import { appRouteLayoutStaticParamsGroups } from "../routing/app-router.js";
-import { NEXT_CACHE_TAGS_HEADER, VINEXT_METADATA_ROUTE_CACHE_HEADER, VINEXT_PRERENDER_CACHE_LIFE_HEADER, VINEXT_PRERENDER_METADATA_ROUTES_PATH, VINEXT_PRERENDER_RENDER_ERROR_HEADER } from "../server/headers.js";
+import { NEXT_CACHE_TAGS_HEADER, VINEXT_METADATA_ROUTE_CACHE_HEADER, VINEXT_PRERENDER_CACHE_LIFE_HEADER, VINEXT_PRERENDER_METADATA_ROUTES_PATH, VINEXT_PRERENDER_RENDER_ERROR_HEADER, VINEXT_PRERENDER_SPECIAL_ERROR_HEADER } from "../server/headers.js";
 import { extractLocaleFromUrl } from "../server/pages-i18n.js";
 import { classifyAppRoute, classifyPagesRoute, getAppRouteRenderEntryPath } from "./report.js";
 import { resolveClientStaleTimeSeconds } from "../utils/cache-control-metadata.js";
@@ -12,6 +12,7 @@ import { NoOpCacheHandler, getCacheHandler, setCacheHandler } from "../shims/cac
 import { headersContextFromRequest, runWithHeadersContext } from "../shims/headers.js";
 import { _consumeRequestScopedCacheLife } from "../shims/cache-request-state.js";
 import { normalizeStaticPathsEntry } from "../routing/route-pattern.js";
+import { createRscRequestUrl } from "../server/app-rsc-cache-busting.js";
 import { readPrerenderSecret } from "./server-manifest.js";
 import { buildPregeneratedConcretePathTable } from "../server/prerender-manifest.js";
 import { concatUint8Arrays, decodeRscEmbeddedChunk } from "../server/app-rsc-embedded-chunks.js";
@@ -1041,17 +1042,22 @@ async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode,
 					const responseCacheLife = readPrerenderCacheLifeHeader(response.headers);
 					const cacheTags = readPrerenderCacheTagsHeader(response.headers);
 					const fatal = response.headers.get(VINEXT_PRERENDER_RENDER_ERROR_HEADER) === "1";
-					if (!response.ok || cacheControl.includes("no-store")) {
+					const specialError = mode === "export" ? null : readPrerenderSpecialErrorHeader(response.headers);
+					const isSpecialError = specialError !== null;
+					const ok = response.ok || isSpecialError;
+					if (!ok || cacheControl.includes("no-store")) {
 						await response.body?.cancel();
 						return {
 							cacheControl,
 							linkHeader,
 							html: null,
-							ok: response.ok,
+							ok,
 							requestCacheLife: null,
 							tags: [],
 							status: response.status,
-							fatal
+							fatal,
+							specialErrorLocation: null,
+							isSpecialError
 						};
 					}
 					const html = await response.text();
@@ -1064,7 +1070,9 @@ async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode,
 						requestCacheLife: responseCacheLife ?? processCacheLife,
 						status: response.status,
 						tags: cacheTags,
-						fatal: false
+						fatal: false,
+						specialErrorLocation: specialError?.location ?? null,
+						isSpecialError
 					};
 				});
 				const htmlCacheControl = htmlRender.cacheControl;
@@ -1092,7 +1100,7 @@ async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode,
 					error: "RSC handler returned no prerender HTML"
 				};
 				const html = isFallback ? markAppPprDynamicFallbackShellHtml(htmlRender.html) : htmlRender.html;
-				let rscData = extractRscPayloadFromPrerenderedHtml(html);
+				let rscData = htmlRender.isSpecialError ? null : extractRscPayloadFromPrerenderedHtml(html);
 				if (rscData === null) {
 					const rscHeaders = new Headers({
 						Accept: "text/x-component",
@@ -1100,7 +1108,7 @@ async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode,
 					});
 					if (prerenderRouteParamsHeader !== null) rscHeaders.set(VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, prerenderRouteParamsHeader);
 					if (isSpeculative) rscHeaders.set(VINEXT_PRERENDER_SPECULATIVE_HEADER, "1");
-					const rscRequest = new Request(`http://localhost${requestPath}`, { headers: rscHeaders });
+					const rscRequest = new Request(`http://localhost${await createRscRequestUrl(requestPath, rscHeaders)}`, { headers: rscHeaders });
 					const rscRes = await runWithHeadersContext(headersContextFromRequest(rscRequest), () => rscHandler(rscRequest));
 					if (!rscRes.ok) {
 						await rscRes.body?.cancel();
@@ -1135,7 +1143,11 @@ async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode,
 					...renderedStale === void 0 ? {} : { stale: renderedStale },
 					router: "app",
 					...htmlRender.tags.length > 0 ? { tags: htmlRender.tags } : {},
-					...htmlRender.linkHeader ? { headers: { link: htmlRender.linkHeader } } : {},
+					...htmlRender.linkHeader || htmlRender.specialErrorLocation !== null ? { headers: {
+						...htmlRender.linkHeader ? { link: htmlRender.linkHeader } : {},
+						...htmlRender.specialErrorLocation !== null ? { location: htmlRender.specialErrorLocation } : {}
+					} } : {},
+					...htmlRender.isSpecialError ? { responseStatus: htmlRender.status } : {},
 					...urlPath !== routePattern ? { path: urlPath } : {},
 					...isFallback ? { fallback: true } : {}
 				};
@@ -1239,6 +1251,19 @@ function readPrerenderCacheLifeHeader(headers) {
 		return null;
 	}
 }
+/** Reads the special-error marker: the page's stored headers, or null. */
+function readPrerenderSpecialErrorHeader(headers) {
+	const value = headers.get(VINEXT_PRERENDER_SPECIAL_ERROR_HEADER);
+	if (!value) return null;
+	try {
+		const parsed = JSON.parse(value);
+		if (typeof parsed !== "object" || parsed === null) return null;
+		const location = parsed.location;
+		return { location: typeof location === "string" ? location : null };
+	} catch {
+		return null;
+	}
+}
 function readPrerenderCacheTagsHeader(headers) {
 	const value = headers.get(NEXT_CACHE_TAGS_HEADER);
 	if (!value) return [];

package/dist/build/run-prerender.js

@@ -124,7 +124,7 @@ async function runPrerender(options) {
 	let totalUrls = 0;
 	let completedUrls = 0;
 	const progress = new PrerenderProgress();
-	const outDir = mode === "export" ? path.join(root, "dist", "client") : path.join(manifestDir, "prerendered-routes");
+	const outDir = mode === "export" ? path.resolve(root, options.routeRootConfig?.clientOutDir ?? path.join("dist", "client")) : path.join(manifestDir, "prerendered-routes");
 	let sharedProdServer = null;
 	let sharedPrerenderSecret;
 	const restorePrerenderPhase = enterPrerenderPhase();

package/dist/build/server-manifest.d.ts

@@ -14,6 +14,13 @@
  * warn when this returns `undefined`.
  */
 export declare function readPrerenderSecret(serverDir: string): string | undefined;
+/**
+ * Read next.config `compress` from `vinext-server.json` in `serverDir`.
+ *
+ * Like `next start`, compression stays on unless the build recorded an
+ * explicit `compress: false`, so builds without the field keep compressing.
+ */
+export declare function readServerCompress(serverDir: string): boolean;
 /**
  * Read every server output root that contains a deployable response-stage
  * graph. Paths are stored relative to the project root so build artifacts stay

package/dist/build/server-manifest.js

@@ -20,6 +20,16 @@ function readPrerenderSecret(serverDir) {
 	return readJsonFile(manifestPath)?.prerenderSecret;
 }
 /**
+* Read next.config `compress` from `vinext-server.json` in `serverDir`.
+*
+* Like `next start`, compression stays on unless the build recorded an
+* explicit `compress: false`, so builds without the field keep compressing.
+*/
+function readServerCompress(serverDir) {
+	const manifestPath = path.join(serverDir, "vinext-server.json");
+	return readJsonFile(manifestPath)?.compress !== false;
+}
+/**
 * Read every server output root that contains a deployable response-stage
 * graph. Paths are stored relative to the project root so build artifacts stay
 * relocatable, then resolved for post-build sidecar updates.
@@ -31,4 +41,4 @@ function readServerRuntimeOutputDirs(serverDir, root) {
 	return manifest.runtimeOutputDirs.filter((outputDir) => typeof outputDir === "string").map((outputDir) => path.resolve(root, outputDir));
 }
 //#endregion
-export { readPrerenderSecret, readServerRuntimeOutputDirs };
+export { readPrerenderSecret, readServerCompress, readServerRuntimeOutputDirs };