vinext 1.0.0-beta.4 → 1.0.0-beta.6

package/README.md

@@ -367,6 +367,49 @@ export default defineConfig({
 > Adding an explicit `rsc()` call fails the build with `[vinext] Duplicate @vitejs/plugin-rsc detected`.
 > Pass `rsc: false` to `vinext()` only if you want to own that registration.
 
+#### Module Federation (client-side)
+
+For client-side Module Federation, configure React and React DOM as singleton shared modules in both the host and remotes:
+
+```ts
+import { federation } from "@module-federation/vite";
+import { defineConfig } from "vite";
+import vinext from "vinext";
+
+export default defineConfig({
+  plugins: [
+    federation({
+      name: "host",
+      shared: {
+        react: { singleton: true },
+        "react/": { singleton: true },
+        "react-dom": { singleton: true },
+        "react-dom/": { singleton: true },
+      },
+    }),
+    vinext(),
+  ],
+});
+```
+
+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
+"use client";
+
+import * as React from "react";
+import { getVinextReact } from "vinext/client";
+
+const { useState } = getVinextReact(React);
+
+export function RemoteCounter() {
+  const [count, setCount] = useState(0);
+  return <button onClick={() => setCount((value) => value + 1)}>{count}</button>;
+}
+```
+
+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.
 
 ### Other platforms (via Nitro)
@@ -638,9 +681,7 @@ vinext({
   cache: {
     data: {
       adapter: require.resolve("./my-adapter.js"),
-      options: {
-        /* … */
-      },
+      options: {/* … */},
     },
   },
 });

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

@@ -1,5 +1,4 @@
 import { UserConfig } from "vite";
-
 //#region src/build/client-build-config.d.ts
 type ClientAssetFileNameInfo = {
   readonly name?: string;

package/dist/build/css-url-assets.d.ts

@@ -1,5 +1,4 @@
 import { Rolldown } from "vite";
-
 //#region src/build/css-url-assets.d.ts
 type BundleAsset = Rolldown.OutputAsset;
 type CssUrlAssetBundle = Rolldown.OutputBundle;

package/dist/build/google-fonts/build-url.d.ts

@@ -1,7 +1,10 @@
 //#region src/build/google-fonts/build-url.d.ts
 type FontAxes = {
-  /** Weight values: explicit faces ("400") or a variable range ("400..800"). */wght?: string[]; /** Ital values, "0" (normal) and/or "1" (italic). */
-  ital?: string[]; /** Other variable axes the caller wants to include, e.g. `[["opsz","14..32"]]`. */
+  /** Weight values: explicit faces ("400") or a variable range ("400..800"). */
+  wght?: string[];
+  /** Ital values, "0" (normal) and/or "1" (italic). */
+  ital?: string[];
+  /** Other variable axes the caller wants to include, e.g. `[["opsz","14..32"]]`. */
   variableAxes?: [string, string][];
 };
 declare function buildGoogleFontsUrl(fontFamily: string, axes: FontAxes, display: string): string;

package/dist/build/google-fonts/font-metadata.d.ts

@@ -6,9 +6,13 @@ type VariableAxisDescriptor = {
   defaultValue: number;
 };
 type FontFamilyMetadata = {
-  /** Available weight values, plus the literal "variable" if a variable face exists. */weights: string[]; /** Available styles, e.g. ["normal"], ["italic"], or both. */
-  styles: string[]; /** Variable axes for this family. Absent when the family has no variable face. */
-  axes?: VariableAxisDescriptor[]; /** Preloadable subsets (e.g. "latin", "latin-ext", "vietnamese"). */
+  /** Available weight values, plus the literal "variable" if a variable face exists. */
+  weights: string[];
+  /** Available styles, e.g. ["normal"], ["italic"], or both. */
+  styles: string[];
+  /** Variable axes for this family. Absent when the family has no variable face. */
+  axes?: VariableAxisDescriptor[];
+  /** Preloadable subsets (e.g. "latin", "latin-ext", "vietnamese"). */
   subsets: string[];
 };
 declare const googleFontsMetadata: Record<string, FontFamilyMetadata>;

package/dist/build/google-fonts/get-axes.d.ts

@@ -1,5 +1,4 @@
 import { FontAxes } from "./build-url.js";
-
 //#region src/build/google-fonts/get-axes.d.ts
 declare function getFontAxes(fontFamily: string, weights: string[], styles: string[], selectedVariableAxes?: string[]): FontAxes;
 //#endregion

package/dist/build/layout-classification.d.ts

@@ -1,9 +1,9 @@
 import { ClassificationReason, LayoutBuildClassification, ModuleGraphStaticReason } from "./layout-classification-types.js";
-
 //#region src/build/layout-classification.d.ts
 type ModuleGraphClassification = "static" | "needs-probe";
 type ModuleGraphClassificationResult = {
-  result: ModuleGraphClassification; /** First dynamic shim module ID encountered during BFS, when any. */
+  result: ModuleGraphClassification;
+  /** First dynamic shim module ID encountered during BFS, when any. */
   firstShimMatch?: string;
 };
 type ModuleInfoProvider = {
@@ -13,8 +13,11 @@ type ModuleInfoProvider = {
   } | null;
 };
 type LayoutEntry = {
-  /** Rollup/Vite module ID for the layout file. */moduleId: string; /** Directory depth from the app root, used to build the stable layout ID. */
-  treePosition: number; /** Segment config source code extracted at build time, or null when absent. */
+  /** Rollup/Vite module ID for the layout file. */
+  moduleId: string;
+  /** Directory depth from the app root, used to build the stable layout ID. */
+  treePosition: number;
+  /** Segment config source code extracted at build time, or null when absent. */
   segmentConfig?: {
     code: string;
   } | null;

package/dist/build/next-client-runtime-manifests.d.ts

@@ -1,5 +1,4 @@
 import { ResolvedNextConfig } from "../config/next-config.js";
-
 //#region src/build/next-client-runtime-manifests.d.ts
 type EmitNextClientRuntimeManifestsOptions = {
   clientDir: string;

package/dist/build/next-client-runtime-manifests.js

@@ -1,27 +1,10 @@
 import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
+import { toClientRewrites } from "../client/client-rewrites.js";
 import fs from "node:fs";
 //#region src/build/next-client-runtime-manifests.ts
-function normalizeRewriteForClientManifest(rewrite) {
-	if (rewrite.destination.startsWith("/")) return {
-		has: rewrite.has,
-		source: rewrite.source,
-		destination: rewrite.destination
-	};
-	return {
-		has: rewrite.has,
-		source: rewrite.source
-	};
-}
-function normalizeRewritesForClientManifest(rewrites) {
-	return {
-		beforeFiles: rewrites.beforeFiles.map(normalizeRewriteForClientManifest),
-		afterFiles: rewrites.afterFiles.map(normalizeRewriteForClientManifest),
-		fallback: rewrites.fallback.map(normalizeRewriteForClientManifest)
-	};
-}
 function buildNextClientBuildManifestContent(rewrites) {
 	const manifest = {
-		__rewrites: normalizeRewritesForClientManifest(rewrites),
+		__rewrites: toClientRewrites(rewrites),
 		sortedPages: []
 	};
 	return `self.__BUILD_MANIFEST = ${JSON.stringify(manifest)};self.__BUILD_MANIFEST_CB && self.__BUILD_MANIFEST_CB()`;

package/dist/build/nitro-route-rules.d.ts

@@ -1,5 +1,4 @@
 import { RouteRow } from "./report.js";
-
 //#region src/build/nitro-route-rules.d.ts
 type NitroRouteRuleConfig = Record<string, unknown> & {
   swr?: boolean | number;

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

@@ -1,5 +1,4 @@
 import { PagesClientAssets } from "../server/pages-client-assets.js";
-
 //#region src/build/pages-client-assets-module.d.ts
 declare const PAGES_CLIENT_ASSETS_MODULE = "vinext-client-assets.js";
 declare function buildPagesClientAssetsModule(assets: PagesClientAssets): string;

package/dist/build/precompress.d.ts

@@ -1,7 +1,11 @@
 //#region src/build/precompress.d.ts
 type PrecompressResult = {
   filesCompressed: number;
-  totalOriginalBytes: number; /** Sum of brotli-compressed sizes (used for compression ratio reporting). */
+  totalOriginalBytes: number;
+  /**
+   * Sum of the representation sizes Brotli negotiation would serve. Falls
+   * back to the original size when Brotli is not beneficial for a file.
+   */
   totalBrotliBytes: number;
 };
 /**
@@ -20,7 +24,8 @@ type PrecompressResult = {
  * emit zero compressed variants.
  */
 declare function precompressAssets(clientDir: string, options?: {
-  /** Subdirectory under `clientDir` containing hashed assets. Defaults to `"_next/static"`. */assetsDir?: string;
+  /** Subdirectory under `clientDir` containing hashed assets. Defaults to `"_next/static"`. */
+  assetsDir?: string;
   onProgress?: (completed: number, total: number, file: string) => void;
 }): Promise<PrecompressResult>;
 //#endregion

package/dist/build/precompress.js

@@ -1,6 +1,8 @@
 import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 import { ASSET_PREFIX_URL_DIR } from "../utils/asset-prefix.js";
+import { isPrecompressedVariantBeneficial } from "../utils/precompressed-variant.js";
 import fsp from "node:fs/promises";
+import { randomUUID } from "node:crypto";
 import { promisify } from "node:util";
 import os from "node:os";
 import zlib from "node:zlib";
@@ -90,21 +92,53 @@ async function precompressAssets(clientDir, options = {}) {
 		const chunk = filePaths.slice(i, i + CONCURRENCY);
 		await Promise.all(chunk.map(async (fullPath) => {
 			const content = await fsp.readFile(fullPath);
-			if (content.length < MIN_SIZE) return;
+			if (content.length < MIN_SIZE) {
+				await removeCompressedVariants(fullPath);
+				return;
+			}
 			const compressions = [brotliCompress(content, { params: { [zlib.constants.BROTLI_PARAM_QUALITY]: 5 } }), gzip(content, { level: 8 })];
 			if (zstdCompress) compressions.push(zstdCompress(content, { params: { [zlib.constants.ZSTD_c_compressionLevel]: 8 } }));
 			const [brContent, gzContent, zstdContent] = await Promise.all(compressions);
-			const writes = [fsp.writeFile(fullPath + ".br", brContent), fsp.writeFile(fullPath + ".gz", gzContent)];
-			if (zstdContent) writes.push(fsp.writeFile(fullPath + ".zst", zstdContent));
-			await Promise.all(writes);
-			result.filesCompressed++;
-			result.totalOriginalBytes += content.length;
-			result.totalBrotliBytes += brContent.length;
+			const outcomes = await Promise.all([
+				writeBeneficialVariant(fullPath + ".br", brContent, content.length, "br"),
+				writeBeneficialVariant(fullPath + ".gz", gzContent, content.length, "gzip"),
+				zstdContent ? writeBeneficialVariant(fullPath + ".zst", zstdContent, content.length, "zstd") : removeFileIfPresent(fullPath + ".zst").then(() => false)
+			]);
+			if (outcomes.some(Boolean)) {
+				result.filesCompressed++;
+				result.totalOriginalBytes += content.length;
+				result.totalBrotliBytes += outcomes[0] ? brContent.length : content.length;
+			}
 		}));
 		processed += chunk.length;
 		onProgress?.(processed, filePaths.length, path.basename(chunk[chunk.length - 1]));
 	}
 	return result;
 }
+async function writeBeneficialVariant(destination, compressed, originalSize, encoding) {
+	if (!isPrecompressedVariantBeneficial(compressed.length, originalSize, encoding)) {
+		await removeFileIfPresent(destination);
+		return false;
+	}
+	const temporary = `${destination}.${process.pid}.${randomUUID()}.tmp`;
+	try {
+		await fsp.writeFile(temporary, compressed);
+		await fsp.rename(temporary, destination);
+	} catch (error) {
+		await removeFileIfPresent(temporary);
+		throw error;
+	}
+	return true;
+}
+async function removeCompressedVariants(fullPath) {
+	await Promise.all([
+		removeFileIfPresent(fullPath + ".br"),
+		removeFileIfPresent(fullPath + ".gz"),
+		removeFileIfPresent(fullPath + ".zst")
+	]);
+}
+async function removeFileIfPresent(filePath) {
+	await fsp.rm(filePath, { force: true });
+}
 //#endregion
 export { precompressAssets };

package/dist/build/prerender-paths.d.ts

@@ -1,6 +1,5 @@
 import { ResolvedNextConfig } from "../config/next-config.js";
 import { VinextRouteRootConfig } from "../config/prerender.js";
-
 //#region src/build/prerender-paths.d.ts
 type PrerenderPathManifest = {
   buildId?: string;
@@ -10,7 +9,8 @@ type PrerenderPathManifest = {
 declare const PRERENDER_PATH_DISCOVERY_ENV = "__VINEXT_PRERENDER_PATH_DISCOVERY";
 declare const PRERENDER_PATHS_MANIFEST = "vinext-prerender-paths.json";
 type EmitPrerenderPathManifestOptions = {
-  root: string; /** Fully resolved Next.js config. Loaded from disk when omitted. */
+  root: string;
+  /** Fully resolved Next.js config. Loaded from disk when omitted. */
   nextConfig?: ResolvedNextConfig;
   appDir?: string | null;
   pagesDir?: string | null;

package/dist/build/prerender-paths.js

@@ -9,6 +9,7 @@ import { BLOCKED_PAGES, PHASE_PRODUCTION_BUILD } from "../shims/constants.js";
 import { loadNextConfig, resolveNextConfig } from "../config/next-config.js";
 import { readPrerenderSecret } from "./server-manifest.js";
 import { startProdServer } from "../server/prod-server.js";
+import { enterPrerenderPhase } from "./prerender-phase.js";
 import { buildUrlFromParams, resolveParentParams } from "./prerender.js";
 import fs from "node:fs";
 //#region src/build/prerender-paths.ts
@@ -96,15 +97,13 @@ async function shouldStartPathDiscoveryServer(options) {
 	return false;
 }
 async function withPrerenderEndpoints(fn) {
-	const previousPrerenderFlag = process.env.VINEXT_PRERENDER;
+	const restorePrerenderPhase = enterPrerenderPhase();
 	const previousPathDiscoveryFlag = process.env[PRERENDER_PATH_DISCOVERY_ENV];
-	process.env.VINEXT_PRERENDER = "1";
 	process.env[PRERENDER_PATH_DISCOVERY_ENV] = "1";
 	try {
 		return await fn();
 	} finally {
-		if (previousPrerenderFlag === void 0) delete process.env.VINEXT_PRERENDER;
-		else process.env.VINEXT_PRERENDER = previousPrerenderFlag;
+		restorePrerenderPhase();
 		if (previousPathDiscoveryFlag === void 0) delete process.env[PRERENDER_PATH_DISCOVERY_ENV];
 		else process.env[PRERENDER_PATH_DISCOVERY_ENV] = previousPathDiscoveryFlag;
 	}

package/dist/build/prerender-phase.d.ts

@@ -0,0 +1,15 @@
+//#region src/build/prerender-phase.d.ts
+type PrerenderPhaseEnv = {
+  NEXT_PHASE?: string;
+  NODE_ENV?: string;
+  VINEXT_PRERENDER?: string;
+};
+/**
+ * Enter the same process environment phase that Next.js exposes while its
+ * static workers execute application code. The returned cleanup is nest-safe:
+ * direct prerender helpers can run inside the CLI's broader build scope without
+ * overwriting the caller's prior phase when they finish.
+ */
+declare function enterPrerenderPhase(env?: PrerenderPhaseEnv): () => void;
+//#endregion
+export { enterPrerenderPhase };

package/dist/build/prerender-phase.js

@@ -0,0 +1,37 @@
+import { PHASE_PRODUCTION_BUILD } from "../shims/constants.js";
+//#region src/build/prerender-phase.ts
+const activePrerenderPhases = /* @__PURE__ */ new WeakMap();
+/**
+* Enter the same process environment phase that Next.js exposes while its
+* static workers execute application code. The returned cleanup is nest-safe:
+* direct prerender helpers can run inside the CLI's broader build scope without
+* overwriting the caller's prior phase when they finish.
+*/
+function enterPrerenderPhase(env = process.env) {
+	let state = activePrerenderPhases.get(env);
+	if (state) state.depth += 1;
+	else {
+		state = {
+			depth: 1,
+			previousPrerenderFlag: env.VINEXT_PRERENDER,
+			previousNextPhase: env.NEXT_PHASE
+		};
+		activePrerenderPhases.set(env, state);
+	}
+	let restored = false;
+	env.VINEXT_PRERENDER = "1";
+	env.NEXT_PHASE = PHASE_PRODUCTION_BUILD;
+	return () => {
+		if (restored) return;
+		restored = true;
+		state.depth -= 1;
+		if (state.depth > 0) return;
+		activePrerenderPhases.delete(env);
+		if (state.previousPrerenderFlag === void 0) delete env.VINEXT_PRERENDER;
+		else env.VINEXT_PRERENDER = state.previousPrerenderFlag;
+		if (state.previousNextPhase === void 0) delete env.NEXT_PHASE;
+		else env.NEXT_PHASE = state.previousNextPhase;
+	};
+}
+//#endregion
+export { enterPrerenderPhase };

package/dist/build/prerender-server-entry.d.ts

@@ -1 +1 @@
-export { };
+export {}

package/dist/build/prerender-server-entry.js

@@ -11,9 +11,9 @@ import { startProdServer } from "../server/prod-server.js";
 * vinext production server on an ephemeral port and reports it to the parent
 * over IPC. The parent then load-balances per-route fetches across the pool.
 *
-* `VINEXT_PRERENDER` / `VINEXT_PRERENDER_OUTDIR` are passed via the fork env so
-* they are set before any module loads (some server modules read the flag at
-* import time).
+* `VINEXT_PRERENDER` / `NEXT_PHASE` / `VINEXT_PRERENDER_OUTDIR` are passed via
+* the fork env so they are set before any module loads (some server and user
+* modules read the phase at import time).
 */
 async function main() {
 	const outDir = process.env.VINEXT_PRERENDER_OUTDIR;

package/dist/build/prerender-server-pool.d.ts

@@ -7,7 +7,8 @@
  */
 declare function prerenderPoolAvailable(): boolean;
 type PrerenderServerPool = {
-  /** Ports of the forked render servers, for round-robin per-route fetches. */ports: number[];
+  /** Ports of the forked render servers, for round-robin per-route fetches. */
+  ports: number[];
   /**
    * Throw if any worker exited unexpectedly (i.e. not via `close()`). The
    * caller MUST call this after the render loop: a crashed worker makes every
@@ -21,7 +22,8 @@ type PrerenderServerPool = {
    * Record a failed fetch to a render worker. This closes the tiny ordering gap
    * where the request can fail before Node has delivered the child `exit` event.
    */
-  recordRenderError: (err: unknown) => void; /** Kill every forked server. Safe to call more than once. */
+  recordRenderError: (err: unknown) => void;
+  /** Kill every forked server. Safe to call more than once. */
   close: () => Promise<void>;
 };
 /**

package/dist/build/prerender-server-pool.js

@@ -1,4 +1,5 @@
 import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
+import { PHASE_PRODUCTION_BUILD } from "../shims/constants.js";
 import fs from "node:fs";
 import { fileURLToPath } from "node:url";
 import os from "node:os";
@@ -105,6 +106,7 @@ async function startPrerenderServerPool(outDir, size, entry = WORKER_ENTRY) {
 				env: {
 					...process.env,
 					VINEXT_PRERENDER: "1",
+					NEXT_PHASE: PHASE_PRODUCTION_BUILD,
 					VINEXT_PRERENDER_OUTDIR: outDir
 				},
 				stdio: [

package/dist/build/prerender.d.ts

@@ -4,27 +4,39 @@ import { AppRoute } from "../routing/app-route-graph.js";
 import { MetadataFileRoute } from "../server/metadata-routes.js";
 import { readPrerenderSecret } from "./server-manifest.js";
 import { Server } from "node:http";
-
 //#region src/build/prerender.d.ts
 type PrerenderResult = {
-  /** One entry per route (including skipped/error routes). */routes: PrerenderRouteResult[]; /** Additional generated files that are not represented as route entries. */
+  /** One entry per route (including skipped/error routes). */
+  routes: PrerenderRouteResult[];
+  /** Additional generated files that are not represented as route entries. */
   outputFiles?: string[];
 };
 type PrerenderRouteResult = {
-  /** The route's file-system pattern, e.g. `/blog/:slug`. */route: string;
+  /** The route's file-system pattern, e.g. `/blog/:slug`. */
+  route: string;
   status: "rendered";
   outputFiles: string[];
   revalidate: number | false;
   expire?: number;
+  /** Client-router reuse bound resolved from the prerender's `cacheLife`. */
+  stale?: number;
   /**
    * The concrete prerendered URL path, e.g. `/blog/hello-world`.
    * Only present when the route is dynamic and `path` differs from `route`.
    * Omitted for non-dynamic routes where pattern === path.
    */
-  path?: string; /** Which router produced this route. Used by cache seeding. */
-  router: "app" | "pages"; /** Response headers that must be replayed with the prerendered artifact. */
-  headers?: Record<string, string>; /** Cache tags collected while rendering this route. */
-  tags?: string[]; /** Set to true when this is a PPR fallback shell. */
+  path?: string;
+  /** Which router produced this route. Used by cache seeding. */
+  router: "app" | "pages" | "metadata";
+  /** Response headers that must be replayed with the prerendered artifact. */
+  headers?: Record<string, string | string[]>;
+  /** Original HTTP status for prerendered App Route-style responses. */
+  responseStatus?: number;
+  /** Cache tags collected while rendering this route. */
+  tags?: string[];
+  /** Raw app-tree segments used to derive App Route implicit tags. */
+  routeSegments?: string[];
+  /** Set to true when this is a PPR fallback shell. */
   fallback?: boolean;
 } | {
   route: string;
@@ -44,9 +56,13 @@ type PrerenderRouteResult = {
 };
 /** Called after each route is resolved (rendered, skipped, or error). */
 type PrerenderProgressCallback = (update: {
-  /** Routes completed so far (rendered + skipped + error). */completed: number; /** Total routes queued for rendering. */
-  total: number; /** The route URL that just finished. */
-  route: string; /** Its final status. */
+  /** Routes completed so far (rendered + skipped + error). */
+  completed: number;
+  /** Total routes queued for rendering. */
+  total: number;
+  /** The route URL that just finished. */
+  route: string;
+  /** Its final status. */
   status: PrerenderRouteResult["status"];
 }) => void;
 type PrerenderOptions = {
@@ -54,7 +70,8 @@ type PrerenderOptions = {
    * 'default' — prerender static/ISR routes; skip SSR routes
    * 'export'  — same as default but SSR routes are errors
    */
-  mode: "default" | "export"; /** Output directory for generated HTML/RSC files. */
+  mode: "default" | "export";
+  /** Output directory for generated HTML/RSC files. */
   outDir: string;
   /**
    * Directory where `vinext-prerender.json` is written.
@@ -62,7 +79,8 @@ type PrerenderOptions = {
    * Set this when the manifest should land in a different location than the
    * generated HTML/RSC files (e.g. `dist/server/` while HTML goes to `dist/server/prerendered-routes/`).
    */
-  manifestDir?: string; /** Resolved next.config.js. */
+  manifestDir?: string;
+  /** Resolved next.config.js. */
   config: ResolvedNextConfig;
   /**
    * Maximum number of routes rendered in parallel.
@@ -82,8 +100,11 @@ type PrerenderOptions = {
   skipManifest?: boolean;
 };
 type PrerenderPagesOptions = {
-  /** Discovered page routes (non-API). */routes: Route[]; /** Discovered API routes. */
-  apiRoutes: Route[]; /** Pages directory path. */
+  /** Discovered page routes (non-API). */
+  routes: Route[];
+  /** Discovered API routes. */
+  apiRoutes: Route[];
+  /** Pages directory path. */
   pagesDir: string;
   /**
    * Absolute path to the pre-built Pages Router server bundle
@@ -95,7 +116,9 @@ type PrerenderPagesOptions = {
   pagesBundlePath?: string;
 } & PrerenderOptions;
 type PrerenderAppOptions = {
-  /** Discovered app routes. */routes: AppRoute[]; /** Discovered file-based metadata routes. Used by static export. */
+  /** Discovered app routes. */
+  routes: AppRoute[];
+  /** Discovered file-based metadata routes. Used by static export. */
   metadataRoutes?: readonly MetadataFileRoute[];
   /**
    * Absolute path to the pre-built RSC handler bundle (e.g. `dist/server/index.js`).
@@ -172,15 +195,7 @@ declare function resolveParentParams(childRoute: AppRoute, staticParamsMap: Stat
  * Writes HTML files to `outDir`. If `manifestDir` is set, writes
  * `vinext-prerender.json` there; otherwise writes it to `outDir`.
  */
-declare function prerenderPages({
-  routes,
-  apiRoutes,
-  pagesDir,
-  outDir,
-  config,
-  mode,
-  ...options
-}: PrerenderPagesOptionsInternal): Promise<PrerenderResult>;
+declare function prerenderPages({ routes, apiRoutes, pagesDir, outDir, config, mode, ...options }: PrerenderPagesOptionsInternal): Promise<PrerenderResult>;
 /**
  * Run the prerender phase for App Router.
  *
@@ -198,15 +213,7 @@ declare function prerenderPages({
  * If they succeed, they are marked as rendered. If they throw a DynamicUsageError
  * or fail, they are marked as skipped with reason 'dynamic'.
  */
-declare function prerenderApp({
-  routes,
-  metadataRoutes,
-  outDir,
-  config,
-  mode,
-  rscBundlePath,
-  ...options
-}: PrerenderAppOptionsInternal): Promise<PrerenderResult>;
+declare function prerenderApp({ routes, metadataRoutes, outDir, config, mode, rscBundlePath, ...options }: PrerenderAppOptionsInternal): Promise<PrerenderResult>;
 /**
  * Write `vinext-prerender.json` to `outDir`.
  *