vinext 1.0.1 → 1.1.0

package/README.md

@@ -158,6 +158,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
@@ -792,7 +828,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 +841,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/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
@@ -351,82 +352,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/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 };

package/dist/cache/cache-adapters-virtual.d.ts

@@ -74,7 +74,13 @@ export type CacheAdapterBuildOutput = {
 export type CacheAdapterDescriptor<O extends Record<string, unknown> = Record<string, unknown>> = {
   /**
    * Module specifier (or absolute path, e.g. from `require.resolve(...)`) whose
-   * default export is a cache adapter factory.
+   * default export creates the adapter from one `{ env, options }` argument:
+   * either a factory `({ env, options }) => adapter` or a class
+   * `new Adapter({ env, options })`. Class syntax is invoked with `new`; any
+   * other function is called. For a constructor that is not class syntax (an
+   * ES5-compiled, bound or Proxy-wrapped class), export
+   * `(args) => new Adapter(args)`. The result must be the adapter object
+   * itself, not a Promise.
    */
   adapter: string;
   /** JSON-serializable options forwarded to the factory at runtime. */

package/dist/cache/cache-adapters-virtual.js

@@ -103,7 +103,7 @@ function generateCacheAdaptersModule(cache) {
 		"export function registerConfiguredCacheAdapters() {}",
 		""
 	].join("\n");
-	const lines = ["// vinext: generated from the `cache` option in your vinext() plugin config."];
+	const lines = ["// vinext: generated from the `cache` option in your vinext() plugin config.", `import { instantiateCacheAdapter } from "vinext/shims/cache-adapter-instantiate";`];
 	if (data?.adapter) {
 		lines.push(`import __vinextDataAdapterFactory from ${JSON.stringify(data.adapter)};`);
 		lines.push(`import { registerDataCacheHandler } from "vinext/shims/cache-handler";`);
@@ -114,11 +114,11 @@ function generateCacheAdaptersModule(cache) {
 	} else if (dataProvidesBuildIdentity) lines.push(`import { DefaultCdnCacheAdapter } from "vinext/shims/cdn-cache";`, `import { registerCdnCacheAdapter } from "vinext/shims/cdn-cache-state";`);
 	lines.push("", "// A factory that throws (e.g. a missing binding on an incompatible runtime)", "// is logged and skipped so the default handler stays in place.", "function __vinextFormatAdapterError(error) {", "  if (error instanceof Error && error.message) return error.message;", "  try {", "    return String(error);", "  } catch {", "    return '<unknown error>';", "  }", "}", "", "let __vinextCacheAdaptersRegistered = false;", "", "export function registerConfiguredCacheAdapters(env) {", "  if (typeof process !== 'undefined' && process.env?.__VINEXT_PRERENDER_PATH_DISCOVERY === '1') return;", "  if (__vinextCacheAdaptersRegistered) return;", "  __vinextCacheAdaptersRegistered = true;");
 	if (data?.adapter) {
-		lines.push("  try {", `    registerDataCacheHandler(() => __vinextDataAdapterFactory({ env, options: ${inlineOptions(data.adapter, data.options)} }));`);
+		lines.push("  try {", `    registerDataCacheHandler(() => instantiateCacheAdapter(__vinextDataAdapterFactory, { env, options: ${inlineOptions(data.adapter, data.options)} }, "data"));`);
 		if (dataProvidesBuildIdentity) lines.push("    registerCdnCacheAdapter(() => new DefaultCdnCacheAdapter(", "      process.env.__VINEXT_RSC_BUILD_IDENTITY || process.env.__VINEXT_BUILD_ID,", "    ));");
 		lines.push("  } catch (error) {", "    console.warn(\"[vinext] failed to initialize the configured data cache adapter; using the default handler.\\n\" + __vinextFormatAdapterError(error));", "  }");
 	}
-	if (cdn?.adapter) lines.push("  try {", `    registerCdnCacheAdapter(() => __vinextCdnAdapterFactory({ env, options: ${inlineOptions(cdn.adapter, cdn.options)} }));`, "  } catch (error) {", "    console.warn(\"[vinext] failed to initialize the configured CDN cache adapter; using the default adapter.\\n\" + __vinextFormatAdapterError(error));", "  }");
+	if (cdn?.adapter) lines.push("  try {", `    registerCdnCacheAdapter(() => instantiateCacheAdapter(__vinextCdnAdapterFactory, { env, options: ${inlineOptions(cdn.adapter, cdn.options)} }, "cdn"));`, "  } catch (error) {", "    console.warn(\"[vinext] failed to initialize the configured CDN cache adapter; using the default adapter.\\n\" + __vinextFormatAdapterError(error));", "  }");
 	lines.push("}", "");
 	return lines.join("\n");
 }

package/dist/client/navigation-runtime.d.ts

@@ -57,6 +57,17 @@ export type NavigationRuntimeFunctions = {
   preparePrefetchResponse?: (response: Response) => Promise<unknown>;
   claimCurrentHistoryTreeSnapshot?: (historyUpdateMode: NavigationRuntimeHistoryUpdateMode, previousHistoryState: unknown) => void;
   commitAppOwnedHistoryStateWrite?: (historyUpdateMode: NavigationRuntimeHistoryUpdateMode, previousHistoryState: unknown) => void;
+  /**
+   * Called after a raw (non-app-owned) history.pushState/replaceState with a
+   * URL so an App Router navigation that has not committed yet is discarded,
+   * matching Next.js' ACTION_RESTORE.
+   */
+  discardPendingNavigation?: () => void;
+  /**
+   * Called before any history.pushState/replaceState so a navigation React is
+   * committing writes its URL first, as Next.js does from an insertion effect.
+   */
+  flushCommittingNavigationUrl?: () => void;
 };
 export type NavigationRuntimeBootstrap = {
   routeManifest: RouteManifest | null;

package/dist/client/navigation-runtime.js

@@ -31,7 +31,7 @@ function readRuntimeWindow() {
 }
 function isNavigationRuntimeFunctions(value) {
 	if (!isUnknownRecord(value)) return false;
-	return isOptionalRuntimeFunction(Reflect.get(value, "clearNavigationCaches")) && isOptionalRuntimeFunction(Reflect.get(value, "commitHashNavigation")) && isOptionalRuntimeFunction(Reflect.get(value, "navigateExternal")) && isOptionalRuntimeFunction(Reflect.get(value, "navigate")) && isOptionalRuntimeFunction(Reflect.get(value, "getPrefetchRouterState")) && isOptionalRuntimeFunction(Reflect.get(value, "notifyLinkNavigationStart")) && isOptionalRuntimeFunction(Reflect.get(value, "pingVisibleLinks")) && isOptionalRuntimeFunction(Reflect.get(value, "preparePrefetchResponse")) && isOptionalRuntimeFunction(Reflect.get(value, "claimCurrentHistoryTreeSnapshot")) && isOptionalRuntimeFunction(Reflect.get(value, "commitAppOwnedHistoryStateWrite"));
+	return isOptionalRuntimeFunction(Reflect.get(value, "clearNavigationCaches")) && isOptionalRuntimeFunction(Reflect.get(value, "commitHashNavigation")) && isOptionalRuntimeFunction(Reflect.get(value, "navigateExternal")) && isOptionalRuntimeFunction(Reflect.get(value, "navigate")) && isOptionalRuntimeFunction(Reflect.get(value, "getPrefetchRouterState")) && isOptionalRuntimeFunction(Reflect.get(value, "notifyLinkNavigationStart")) && isOptionalRuntimeFunction(Reflect.get(value, "pingVisibleLinks")) && isOptionalRuntimeFunction(Reflect.get(value, "preparePrefetchResponse")) && isOptionalRuntimeFunction(Reflect.get(value, "claimCurrentHistoryTreeSnapshot")) && isOptionalRuntimeFunction(Reflect.get(value, "commitAppOwnedHistoryStateWrite")) && isOptionalRuntimeFunction(Reflect.get(value, "discardPendingNavigation")) && isOptionalRuntimeFunction(Reflect.get(value, "flushCommittingNavigationUrl"));
 }
 function isNavigationRuntimeRscChunk(value) {
 	if (typeof value === "string") return true;

package/dist/config/config-matchers.js

@@ -307,6 +307,7 @@ function applyMiddlewareRequestHeaders(middlewareHeaders, request) {
 		method: request.method,
 		headers: nextHeaders,
 		body: request.body,
+		signal: request.signal,
 		duplex: request.body ? "half" : void 0
 	});
 	return {
@@ -859,9 +860,10 @@ async function proxyExternalRequest(request, externalUrl) {
 	try {
 		upstreamResponse = await fetch(targetUrl.href, {
 			...init,
-			signal: controller.signal
+			signal: AbortSignal.any([request.signal, controller.signal])
 		});
 	} catch (e) {
+		if (request.signal.aborted && !controller.signal.aborted) return new Response(null, { status: 499 });
 		if (e instanceof Error && e.name === "AbortError") {
 			console.error("[vinext] External rewrite proxy timeout:", targetUrl.href);
 			return new Response("Gateway Timeout", { status: 504 });

package/dist/config/next-config.d.ts

@@ -111,6 +111,11 @@ export type NextConfig = {
   crossOrigin?: "anonymous" | "use-credentials";
   /** Whether to add trailing slashes */
   trailingSlash?: boolean;
+  /**
+   * Compress responses from the Node production server. Defaults to true.
+   * @see https://nextjs.org/docs/app/api-reference/config/next-config-js/compress
+   */
+  compress?: boolean;
   /** Keep the original request URL visible to middleware/proxy. */
   skipProxyUrlNormalize?: boolean;
   /** @deprecated Use `skipProxyUrlNormalize` instead. */
@@ -312,6 +317,8 @@ export type ResolvedNextConfig = {
    */
   assetPrefix: string;
   trailingSlash: boolean;
+  /** Whether the Node production server compresses responses (`compress`, default true). */
+  compress: boolean;
   skipProxyUrlNormalize: boolean;
   typescript: {
     tsconfigPath?: string;

package/dist/config/next-config.js

@@ -1,5 +1,5 @@
 import path, { toSlash } from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
-import { normalizePageExtensions } from "../routing/file-matcher.js";
+import { DEFAULT_PAGE_EXTENSIONS, normalizePageExtensions } from "../routing/file-matcher.js";
 import { loadCommonJsModule, shouldRetryAsCommonJs } from "../utils/commonjs-loader.js";
 import { isUnknownRecord } from "../utils/record.js";
 import { PHASE_DEVELOPMENT_SERVER, PHASE_PRODUCTION_BUILD } from "../shims/constants.js";
@@ -184,11 +184,24 @@ function warnConfigLoadFailure(filename, err) {
 	if (isNextIntlPlugin) console.warn("[vinext] Hint: createNextIntlPlugin() is not needed with vinext. Remove the next-intl/plugin wrapper from your next.config — vinext auto-detects next-intl and registers the i18n config alias automatically.");
 }
 /**
+* The `defaultConfig` handed to a function-form next.config. Next.js passes
+* its full `defaultConfig` (packages/next/src/server/config-shared.ts); vinext
+* passes the subset configs are known to read, with values matching Next.js,
+* so `[...defaultConfig.pageExtensions, "page.js"]` works. Fresh per call so a
+* config that mutates it cannot leak into later loads.
+*/
+function createFunctionConfigDefaults() {
+	return {
+		pageExtensions: [...DEFAULT_PAGE_EXTENSIONS],
+		compress: true
+	};
+}
+/**
 * Resolve a Next-style config value, calling it if it's a function-form config
 * (Next.js supports `module.exports = (phase, opts) => config`).
 */
 async function resolveConfigValue(config, phase = DEFAULT_PHASE) {
-	if (typeof config === "function") return await config(phase, { defaultConfig: {} });
+	if (typeof config === "function") return await config(phase, { defaultConfig: createFunctionConfigDefaults() });
 	return config;
 }
 /**
@@ -436,7 +449,7 @@ async function loadNextConfigWithPackageIdentity(root, phase) {
 					},
 					load(id) {
 						if (id !== resolvedVirtualConfigId) return;
-						return `import * as configModule from ${configPathLiteral};\nconst cjsModule = configModule[${JSON.stringify(VINEXT_CJS_EXPORTS_KEY)}];\nconst cjsInitial = configModule[${JSON.stringify(VINEXT_CJS_INITIAL_KEY)}];\nconst cjsExports = cjsModule && cjsModule.exports;\nconst cjsValue = cjsExports != null && (cjsExports !== cjsInitial || (typeof cjsExports === "object" && Object.keys(cjsExports).length > 0)) ? cjsExports : undefined;\nconst value = cjsValue ?? configModule.default ?? configModule;\nexport default typeof value === "function" ? await value(${phaseLiteral}, { defaultConfig: {} }) : value;\n`;
+						return `import * as configModule from ${configPathLiteral};\nconst cjsModule = configModule[${JSON.stringify(VINEXT_CJS_EXPORTS_KEY)}];\nconst cjsInitial = configModule[${JSON.stringify(VINEXT_CJS_INITIAL_KEY)}];\nconst cjsExports = cjsModule && cjsModule.exports;\nconst cjsValue = cjsExports != null && (cjsExports !== cjsInitial || (typeof cjsExports === "object" && Object.keys(cjsExports).length > 0)) ? cjsExports : undefined;\nconst value = cjsValue ?? configModule.default ?? configModule;\nexport default typeof value === "function" ? await value(${phaseLiteral}, { defaultConfig: ${JSON.stringify(createFunctionConfigDefaults())} }) : value;\n`;
 					}
 				},
 				...isTypeScriptConfig ? [cjsGlobalsInjectorPlugin(configPath)] : [],
@@ -748,6 +761,7 @@ async function resolveNextConfig(config, root = toSlash(process.cwd()), options
 			basePath: "",
 			assetPrefix: "",
 			trailingSlash: false,
+			compress: true,
 			skipProxyUrlNormalize: false,
 			typescript: {},
 			output: "",
@@ -933,6 +947,7 @@ async function resolveNextConfig(config, root = toSlash(process.cwd()), options
 		basePath: config.basePath ?? "",
 		assetPrefix: normalizeAssetPrefix(config.assetPrefix),
 		trailingSlash: config.trailingSlash ?? false,
+		compress: config.compress !== false,
 		skipProxyUrlNormalize: config.skipProxyUrlNormalize ?? config.skipMiddlewareUrlNormalize ?? false,
 		typescript: typeof config.typescript?.tsconfigPath === "string" ? { tsconfigPath: config.typescript.tsconfigPath } : {},
 		output: output === "export" || output === "standalone" ? output : "",

package/dist/entries/app-rsc-entry.d.ts

@@ -60,6 +60,8 @@ type AppRouterConfig = {
   globalNotFound?: boolean;
   /** Enables Next.js Cache Components semantics for App Router document HTML. */
   cacheComponents?: boolean;
+  /** Reads an MDX source's ESM exports, as the prerender listing does. */
+  readMdxEsm?: ((source: string) => string) | null;
   /** Resolved `experimental.prefetchInlining` thresholds. */
   prefetchInlining?: PrefetchInliningConfig;
   /** Whether the RSC build discovered any server references. Defaults to true. */