@qzsy/vinext 0.1.7

package/dist/build/route-classification-injector.js

@@ -0,0 +1,59 @@
+import { buildClassificationReplacement, buildReasonsReplacement } from "./route-classification-manifest.js";
+import { classifyLayoutByModuleGraph, isStaticModuleGraphResult, moduleGraphReason } from "./layout-classification.js";
+//#region src/build/route-classification-injector.ts
+const CLASS_STUB_RE = /function __VINEXT_CLASS\(routeIdx\)\s*\{\s*return null;?\s*\}/;
+const REASONS_STUB_RE = /function __VINEXT_CLASS_REASONS\(routeIdx\)\s*\{\s*return null;?\s*\}/;
+function identityPath(path) {
+	return path;
+}
+function findClassificationChunk(chunks) {
+	const chunksMentioningStub = chunks.filter((chunk) => chunk.code.includes("__VINEXT_CLASS"));
+	const chunksWithStubBody = chunksMentioningStub.filter((chunk) => CLASS_STUB_RE.test(chunk.code));
+	const chunkWithStubBody = chunksWithStubBody[0];
+	if (chunksMentioningStub.length === 0) return null;
+	if (chunkWithStubBody === void 0) throw new Error(`vinext: build-time classification — __VINEXT_CLASS is referenced in ${chunksMentioningStub.map((chunk) => chunk.fileName).join(", ")} but no chunk contains the stub body. The generator and the classification injector have drifted.`);
+	if (chunksWithStubBody.length > 1) throw new Error(`vinext: build-time classification — expected __VINEXT_CLASS stub in exactly one RSC chunk, found ${chunksWithStubBody.length}`);
+	return chunkWithStubBody;
+}
+function buildLayer2Classifications(options) {
+	const canonicalizeLayoutPath = options.canonicalizeLayoutPath ?? identityPath;
+	const layer2PerRoute = /* @__PURE__ */ new Map();
+	const graphCache = /* @__PURE__ */ new Map();
+	for (let routeIdx = 0; routeIdx < options.manifest.routes.length; routeIdx++) {
+		const route = options.manifest.routes[routeIdx];
+		const perRoute = /* @__PURE__ */ new Map();
+		for (let layoutIdx = 0; layoutIdx < route.layoutPaths.length; layoutIdx++) {
+			if (route.layer1.has(layoutIdx)) continue;
+			const layoutModuleId = canonicalizeLayoutPath(route.layoutPaths[layoutIdx]);
+			if (!options.moduleInfo.getModuleInfo(layoutModuleId)) continue;
+			let graphResult = graphCache.get(layoutModuleId);
+			if (graphResult === void 0) {
+				graphResult = classifyLayoutByModuleGraph(layoutModuleId, options.dynamicShimPaths, options.moduleInfo);
+				graphCache.set(layoutModuleId, graphResult);
+			}
+			if (isStaticModuleGraphResult(graphResult)) perRoute.set(layoutIdx, moduleGraphReason(graphResult));
+		}
+		if (perRoute.size > 0) layer2PerRoute.set(routeIdx, perRoute);
+	}
+	return layer2PerRoute;
+}
+function planRouteClassificationInjection(options) {
+	const target = findClassificationChunk(options.chunks);
+	if (!target) return { kind: "skip" };
+	if (options.enableDebugReasons && !REASONS_STUB_RE.test(target.code)) throw new Error("vinext: build-time classification — __VINEXT_CLASS_REASONS stub is missing alongside __VINEXT_CLASS. The generator and the classification injector have drifted.");
+	const layer2PerRoute = buildLayer2Classifications(options);
+	const patchedBody = `function __VINEXT_CLASS(routeIdx) { return (${buildClassificationReplacement(options.manifest, layer2PerRoute)})(routeIdx); }`;
+	let code = target.code.replace(CLASS_STUB_RE, patchedBody);
+	if (options.enableDebugReasons) {
+		const patchedReasonsBody = `function __VINEXT_CLASS_REASONS(routeIdx) { return (${buildReasonsReplacement(options.manifest, layer2PerRoute)})(routeIdx); }`;
+		code = code.replace(REASONS_STUB_RE, patchedReasonsBody);
+	}
+	return {
+		code,
+		fileName: target.fileName,
+		kind: "patch",
+		map: null
+	};
+}
+//#endregion
+export { planRouteClassificationInjection };

package/dist/build/route-classification-manifest.d.ts

@@ -0,0 +1,52 @@
+import { ClassificationReason, ModuleGraphStaticReason } from "./layout-classification-types.js";
+import { AppRoute } from "../routing/app-route-graph.js";
+
+//#region src/build/route-classification-manifest.d.ts
+type Layer1Class = "static" | "dynamic";
+type RouteManifestEntry = {
+  /** Route pattern for diagnostics (e.g. "/blog/:slug"). */pattern: string; /** Absolute file paths for each layout, ordered root → leaf. */
+  layoutPaths: string[]; /** Layer 1 (segment config) results keyed by numeric layout index. */
+  layer1: Map<number, Layer1Class>;
+  /**
+   * Structured reasons for every Layer 1 decision, keyed by the same layout
+   * index. Always populated in lockstep with `layer1` so the debug channel
+   * can surface which segment-config field produced the decision.
+   */
+  layer1Reasons: Map<number, ClassificationReason>;
+};
+type RouteClassificationManifest = {
+  routes: RouteManifestEntry[];
+};
+/**
+ * Reads each layout's source at build time and runs Layer 1 segment-config
+ * classification. Fails loudly if any layout file is missing — a missing
+ * layout means the routing scan and the filesystem have drifted, and shipping
+ * a build in that state would silently break layout rendering.
+ */
+declare function collectRouteClassificationManifest(routes: readonly AppRoute[]): RouteClassificationManifest;
+/**
+ * Builds a JavaScript arrow-function expression that dispatches route index
+ * to a pre-computed `Map<layoutIndex, "static" | "dynamic">` of build-time
+ * classifications. The returned string is suitable for embedding into the
+ * generated RSC entry via the `renderChunk` hook.
+ *
+ * `layer2PerRoute` is typed to only carry `"static"` entries — the
+ * module-graph classifier can only prove static, so "needs-probe" results
+ * are omitted by the caller before this map is constructed.
+ */
+declare function buildClassificationReplacement(manifest: RouteClassificationManifest, layer2PerRoute: ReadonlyMap<number, ReadonlyMap<number, ModuleGraphStaticReason>>): string;
+/**
+ * Sibling of `buildClassificationReplacement`: emits a dispatch function
+ * that returns `Map<layoutIndex, ClassificationReason>` per route.
+ *
+ * The runtime consults this map only when `VINEXT_DEBUG_CLASSIFICATION` is
+ * set, and the plugin only patches this dispatcher into the built bundle when
+ * that env var is present at build time.
+ *
+ * Layer 1 priority applies the same way as in `buildClassificationReplacement`:
+ * a segment-config reason must override a module-graph reason for the same
+ * layout index.
+ */
+declare function buildReasonsReplacement(manifest: RouteClassificationManifest, layer2PerRoute: ReadonlyMap<number, ReadonlyMap<number, ModuleGraphStaticReason>>): string;
+//#endregion
+export { RouteClassificationManifest, buildClassificationReplacement, buildReasonsReplacement, collectRouteClassificationManifest };

package/dist/build/route-classification-manifest.js

@@ -0,0 +1,143 @@
+import { classifyLayoutSegmentConfig } from "./report.js";
+import fs from "node:fs";
+//#region src/build/route-classification-manifest.ts
+/**
+* Build-time layout classification manifest.
+*
+* Bridges the classifier in `./layout-classification.ts` with the RSC entry
+* codegen so that the per-layout static/dynamic classifications produced at
+* build time are visible to the runtime probe loop in
+* `server/app-page-execution.ts`.
+*
+* The runtime probe looks up entries by numeric `layoutIndex`, so this module
+* is responsible for flattening the classifier's string-keyed layout IDs into
+* a per-route, index-keyed structure that can be emitted from codegen.
+*/
+/**
+* Reads each layout's source at build time and runs Layer 1 segment-config
+* classification. Fails loudly if any layout file is missing — a missing
+* layout means the routing scan and the filesystem have drifted, and shipping
+* a build in that state would silently break layout rendering.
+*/
+function collectRouteClassificationManifest(routes) {
+	const manifestRoutes = [];
+	const sourceCache = /* @__PURE__ */ new Map();
+	for (const route of routes) {
+		const layer1 = /* @__PURE__ */ new Map();
+		const layer1Reasons = /* @__PURE__ */ new Map();
+		for (let layoutIndex = 0; layoutIndex < route.layouts.length; layoutIndex++) {
+			const layoutPath = route.layouts[layoutIndex];
+			let source = sourceCache.get(layoutPath);
+			if (source === void 0) try {
+				source = fs.readFileSync(layoutPath, "utf8");
+				sourceCache.set(layoutPath, source);
+			} catch (cause) {
+				throw new Error(`vinext: failed to read layout for route ${route.pattern} at ${layoutPath}`, { cause });
+			}
+			const result = classifyLayoutSegmentConfig(source);
+			if (result.kind === "static" || result.kind === "dynamic") {
+				layer1.set(layoutIndex, result.kind);
+				layer1Reasons.set(layoutIndex, result.reason);
+			}
+		}
+		manifestRoutes.push({
+			pattern: route.pattern,
+			layoutPaths: [...route.layouts],
+			layer1,
+			layer1Reasons
+		});
+	}
+	return { routes: manifestRoutes };
+}
+/**
+* Merges Layer 1 (segment config) and Layer 2 (module graph) into a single
+* per-route map, applying the Layer-1-wins priority rule.
+*
+* Layer 1 always takes priority over Layer 2 for the same layout index:
+* segment config is a user-authored guarantee, so a layout that explicitly
+* says `force-dynamic` must never be demoted to "static" because its module
+* graph happened to be clean.
+*/
+function mergeLayersForRoute(route, layer2) {
+	const merged = /* @__PURE__ */ new Map();
+	if (layer2) for (const [layoutIdx, reason] of layer2) merged.set(layoutIdx, {
+		kind: "static",
+		reason
+	});
+	for (const [layoutIdx, kind] of route.layer1) {
+		const reason = route.layer1Reasons.get(layoutIdx);
+		if (reason === void 0) throw new Error(`vinext: layout ${layoutIdx} in route ${route.pattern} has a Layer 1 decision without a reason`);
+		merged.set(layoutIdx, {
+			kind,
+			reason
+		});
+	}
+	return merged;
+}
+function serializeReasonExpression(reason) {
+	switch (reason.layer) {
+		case "segment-config": {
+			const value = reason.value === Infinity ? "Infinity" : JSON.stringify(reason.value);
+			return `{ layer: "segment-config", key: ${JSON.stringify(reason.key)}, value: ${value} }`;
+		}
+		case "module-graph": {
+			const props = [`layer: "module-graph"`, `result: ${JSON.stringify(reason.result)}`];
+			if (reason.firstShimMatch !== void 0) props.push(`firstShimMatch: ${JSON.stringify(reason.firstShimMatch)}`);
+			return `{ ${props.join(", ")} }`;
+		}
+		case "runtime-probe": {
+			const props = [`layer: "runtime-probe"`, `outcome: ${JSON.stringify(reason.outcome)}`];
+			if (reason.error !== void 0) props.push(`error: ${JSON.stringify(reason.error)}`);
+			return `{ ${props.join(", ")} }`;
+		}
+		case "no-classifier": return `{ layer: "no-classifier" }`;
+	}
+}
+function buildRouteDispatchReplacement(manifest, layer2PerRoute, serializeEntry) {
+	const cases = [];
+	for (let routeIdx = 0; routeIdx < manifest.routes.length; routeIdx++) {
+		const route = manifest.routes[routeIdx];
+		const merged = mergeLayersForRoute(route, layer2PerRoute.get(routeIdx));
+		if (merged.size === 0) continue;
+		const entries = [...merged.entries()].sort((a, b) => a[0] - b[0]).map(([idx, value]) => `[${idx}, ${serializeEntry(value)}]`).join(", ");
+		cases.push(`      case ${routeIdx}: return new Map([${entries}]);`);
+	}
+	return [
+		"(routeIdx) => {",
+		"    switch (routeIdx) {",
+		...cases,
+		"      default: return null;",
+		"    }",
+		"  }"
+	].join("\n");
+}
+/**
+* Builds a JavaScript arrow-function expression that dispatches route index
+* to a pre-computed `Map<layoutIndex, "static" | "dynamic">` of build-time
+* classifications. The returned string is suitable for embedding into the
+* generated RSC entry via the `renderChunk` hook.
+*
+* `layer2PerRoute` is typed to only carry `"static"` entries — the
+* module-graph classifier can only prove static, so "needs-probe" results
+* are omitted by the caller before this map is constructed.
+*/
+function buildClassificationReplacement(manifest, layer2PerRoute) {
+	return buildRouteDispatchReplacement(manifest, layer2PerRoute, (value) => JSON.stringify(value.kind));
+}
+/**
+* Sibling of `buildClassificationReplacement`: emits a dispatch function
+* that returns `Map<layoutIndex, ClassificationReason>` per route.
+*
+* The runtime consults this map only when `VINEXT_DEBUG_CLASSIFICATION` is
+* set, and the plugin only patches this dispatcher into the built bundle when
+* that env var is present at build time.
+*
+* Layer 1 priority applies the same way as in `buildClassificationReplacement`:
+* a segment-config reason must override a module-graph reason for the same
+* layout index.
+*/
+function buildReasonsReplacement(manifest, layer2PerRoute) {
+	return buildRouteDispatchReplacement(manifest, layer2PerRoute, (value) => serializeReasonExpression(value.reason));
+}
+//#endregion
+export { buildClassificationReplacement, buildReasonsReplacement, collectRouteClassificationManifest };

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

@@ -0,0 +1,61 @@
+import { ResolvedNextConfig } from "../config/next-config.js";
+import { PrerenderResult, PrerenderRouteResult } from "./prerender.js";
+
+//#region src/build/run-prerender.d.ts
+type RunPrerenderOptions = {
+  /** Project root directory. */root: string;
+  /**
+   * Override next.config values. Merged on top of the config loaded from disk.
+   * Intended for tests that need to exercise a specific config (e.g. output: 'export')
+   * without writing a next.config file.
+   */
+  nextConfigOverride?: Partial<ResolvedNextConfig>;
+  /**
+   * Override the path to the Pages Router server bundle.
+   * Defaults to `<root>/dist/server/entry.js`.
+   * Intended for tests that build to a custom outDir.
+   */
+  pagesBundlePath?: string;
+  /**
+   * Override the path to the App Router RSC bundle.
+   * Defaults to `<root>/dist/server/index.js`.
+   * Intended for tests that build to a custom outDir.
+   */
+  rscBundlePath?: string;
+  /**
+   * Maximum number of routes rendered in parallel.
+   * Defaults to prerenderApp/prerenderPages internal defaults when omitted.
+   */
+  concurrency?: number;
+};
+/**
+ * Run the prerender phase using pre-built production bundles.
+ *
+ * Scans routes, starts a local production server, renders every static/ISR
+ * route via HTTP, writes output files to `dist/server/prerendered-routes/`
+ * (non-export) or `dist/client/` (export), and prints a progress bar + summary
+ * to stderr/stdout. Returns the full PrerenderResult so callers can pass it to
+ * printBuildReport.
+ *
+ * Works for both plain Node and Cloudflare Workers builds — the CF Workers
+ * bundle outputs `dist/server/index.js` which is a standard Node server entry,
+ * so no wrangler/miniflare is needed.
+ *
+ * Hybrid projects (both `app/` and `pages/` present) run both prerender
+ * phases sharing a single prod server instance. The merged results are written
+ * to a single `dist/server/vinext-prerender.json`.
+ *
+ * If a required production bundle does not exist, an error is thrown directing
+ * the user to run `vinext build` first.
+ */
+/**
+ * Throw if any route is a `fatal` error (a thrown generateStaticParams /
+ * getStaticPaths). These fail the build in ALL modes — default included —
+ * matching `next build`, unlike intentionally-skipped dynamic/SSR routes and
+ * non-fatal errors (e.g. transport failures), which only fail under
+ * `output: 'export'`. Exported for direct unit testing. Refs cloudflare/vinext#1982
+ */
+declare function assertNoFatalPrerenderRoutes(routes: readonly PrerenderRouteResult[]): void;
+declare function runPrerender(options: RunPrerenderOptions): Promise<PrerenderResult | null>;
+//#endregion
+export { assertNoFatalPrerenderRoutes, runPrerender };

package/dist/build/run-prerender.js

@@ -0,0 +1,224 @@
+import { findDir } from "../utils/project.js";
+import { apiRouter, pagesRouter } from "../routing/pages-router.js";
+import { appRouter } from "../routing/app-router.js";
+import { scanMetadataFiles } from "../server/metadata-routes.js";
+import { loadNextConfig, resolveNextConfig } from "../config/next-config.js";
+import { readPrerenderSecret } from "./server-manifest.js";
+import { startProdServer } from "../server/prod-server.js";
+import { prerenderApp, prerenderPages, writePrerenderIndex } from "./prerender.js";
+import fs from "node:fs";
+import path from "node:path";
+//#region src/build/run-prerender.ts
+/**
+* Shared prerender runner used by both `vinext build` (cli.ts) and
+* `vinext deploy --prerender-all` (deploy.ts).
+*
+* `runPrerender` handles route scanning, dynamic imports, progress reporting,
+* and result summarisation.
+*
+* Output files (HTML/RSC payloads) are written to
+* `dist/server/prerendered-routes/` for non-export builds, co-located with
+* server artifacts and away from the static assets directory. On Cloudflare
+* Workers, `not_found_handling: "none"` means every request hits the worker
+* first, so files in `dist/client/` are never auto-served for page requests.
+* For `output: 'export'` builds the caller controls `outDir` via
+* `static-export.ts`, which passes `dist/client/` directly.
+*
+* Hybrid projects (both `app/` and `pages/` directories) are handled by
+* running both prerender phases and merging results into a single
+* `dist/server/vinext-prerender.json` manifest.
+*/
+/**
+* Live progress reporter for the prerender phase.
+*
+* Writes a single updating line to stderr using \r so it doesn't interleave
+* with Vite's stdout output. Automatically clears on finish().
+*/
+var PrerenderProgress = class {
+	isTTY = process.stderr.isTTY;
+	lastLineLen = 0;
+	update(completed, total, route) {
+		if (!this.isTTY) return;
+		const pct = total > 0 ? Math.floor(completed / total * 100) : 0;
+		const bar = `[${"█".repeat(Math.floor(pct / 5))}${" ".repeat(20 - Math.floor(pct / 5))}]`;
+		const routeLabel = route.length > 40 ? "…" + route.slice(-39) : route;
+		const line = `Prerendering routes... ${bar} ${String(completed).padStart(String(total).length)}/${total} ${routeLabel}`;
+		const padded = line.padEnd(this.lastLineLen);
+		this.lastLineLen = line.length;
+		process.stderr.write(`\r${padded}`);
+	}
+	finish(rendered, skipped, errors) {
+		if (this.isTTY) process.stderr.write(`\r${" ".repeat(this.lastLineLen)}\r`);
+		const errorPart = errors > 0 ? `, ${errors} error${errors !== 1 ? "s" : ""}` : "";
+		console.log(`  Prerendered ${rendered} routes (${skipped} skipped${errorPart}).`);
+	}
+};
+function readBuiltBuildId(serverDir) {
+	try {
+		const buildId = fs.readFileSync(path.join(serverDir, "BUILD_ID"), "utf-8").trim();
+		return buildId.length > 0 ? buildId : null;
+	} catch (error) {
+		if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") return null;
+		throw error;
+	}
+}
+/**
+* Run the prerender phase using pre-built production bundles.
+*
+* Scans routes, starts a local production server, renders every static/ISR
+* route via HTTP, writes output files to `dist/server/prerendered-routes/`
+* (non-export) or `dist/client/` (export), and prints a progress bar + summary
+* to stderr/stdout. Returns the full PrerenderResult so callers can pass it to
+* printBuildReport.
+*
+* Works for both plain Node and Cloudflare Workers builds — the CF Workers
+* bundle outputs `dist/server/index.js` which is a standard Node server entry,
+* so no wrangler/miniflare is needed.
+*
+* Hybrid projects (both `app/` and `pages/` present) run both prerender
+* phases sharing a single prod server instance. The merged results are written
+* to a single `dist/server/vinext-prerender.json`.
+*
+* If a required production bundle does not exist, an error is thrown directing
+* the user to run `vinext build` first.
+*/
+/**
+* Throw if any route is a `fatal` error (a thrown generateStaticParams /
+* getStaticPaths). These fail the build in ALL modes — default included —
+* matching `next build`, unlike intentionally-skipped dynamic/SSR routes and
+* non-fatal errors (e.g. transport failures), which only fail under
+* `output: 'export'`. Exported for direct unit testing. Refs cloudflare/vinext#1982
+*/
+function assertNoFatalPrerenderRoutes(routes) {
+	const fatalRoutes = routes.filter((r) => r.status === "error" && r.fatal === true);
+	if (fatalRoutes.length === 0) return;
+	const fatalList = fatalRoutes.map((r) => `  ${r.route}: ${r.error}`).join("\n");
+	throw new Error(`Prerender failed: ${fatalRoutes.length} route${fatalRoutes.length !== 1 ? "s" : ""} errored during static generation.\n${fatalList}`);
+}
+async function runPrerender(options) {
+	const { root } = options;
+	const appDir = findDir(root, "app", "src/app");
+	const pagesDir = findDir(root, "pages", "src/pages");
+	if (!appDir && !pagesDir) return null;
+	const previousPrerenderFlag = process.env.VINEXT_PRERENDER;
+	process.env.VINEXT_PRERENDER = "1";
+	const manifestDir = path.join(root, "dist", "server");
+	const rscBundlePath = options.rscBundlePath ?? path.join(root, "dist", "server", "index.js");
+	const serverDir = path.dirname(rscBundlePath);
+	const loadedConfig = await resolveNextConfig(await loadNextConfig(root), root);
+	const config = options.nextConfigOverride ? {
+		...loadedConfig,
+		...options.nextConfigOverride
+	} : { ...loadedConfig };
+	const builtBuildId = readBuiltBuildId(serverDir);
+	if (builtBuildId) config.buildId = builtBuildId;
+	const mode = config.output === "export" ? "export" : "default";
+	const allRoutes = [];
+	const allOutputFiles = [];
+	let totalUrls = 0;
+	let completedUrls = 0;
+	const progress = new PrerenderProgress();
+	const outDir = mode === "export" ? path.join(root, "dist", "client") : path.join(root, "dist", "server", "prerendered-routes");
+	let sharedProdServer = null;
+	let sharedPrerenderSecret;
+	try {
+		if (appDir && pagesDir) {
+			sharedProdServer = await startProdServer({
+				port: 0,
+				host: "127.0.0.1",
+				outDir: path.dirname(serverDir),
+				noCompression: true,
+				purpose: "prerender"
+			});
+			sharedPrerenderSecret = readPrerenderSecret(serverDir);
+		}
+		if (appDir) {
+			const routes = await appRouter(appDir, config.pageExtensions);
+			const metadataRoutes = scanMetadataFiles(appDir);
+			let appTotal = 0;
+			const result = await prerenderApp({
+				mode,
+				routes,
+				metadataRoutes,
+				outDir,
+				skipManifest: true,
+				config,
+				concurrency: options.concurrency,
+				rscBundlePath,
+				...sharedProdServer ? { _prodServer: sharedProdServer } : {},
+				onProgress: ({ total, route }) => {
+					if (appTotal === 0) {
+						appTotal = total;
+						totalUrls += total;
+					}
+					completedUrls += 1;
+					progress.update(completedUrls, totalUrls, route);
+				}
+			});
+			allRoutes.push(...result.routes);
+			if (result.outputFiles) allOutputFiles.push(...result.outputFiles);
+		}
+		if (pagesDir) {
+			const [pageRoutes, apiRoutes] = await Promise.all([pagesRouter(pagesDir, config.pageExtensions), apiRouter(pagesDir, config.pageExtensions)]);
+			let pagesTotal = 0;
+			const result = await prerenderPages({
+				mode,
+				routes: pageRoutes,
+				apiRoutes,
+				pagesDir,
+				outDir,
+				skipManifest: true,
+				config,
+				concurrency: options.concurrency,
+				...sharedProdServer ? {
+					_prodServer: sharedProdServer,
+					_prerenderSecret: sharedPrerenderSecret
+				} : { pagesBundlePath: options.pagesBundlePath ?? path.join(root, "dist", "server", "entry.js") },
+				onProgress: ({ total, route }) => {
+					if (pagesTotal === 0) {
+						pagesTotal = total;
+						totalUrls += total;
+					}
+					completedUrls += 1;
+					progress.update(completedUrls, totalUrls, route);
+				}
+			});
+			allRoutes.push(...result.routes);
+			if (result.outputFiles) allOutputFiles.push(...result.outputFiles);
+		}
+	} finally {
+		if (sharedProdServer) await new Promise((resolve) => sharedProdServer.server.close(() => resolve()));
+		if (previousPrerenderFlag === void 0) delete process.env.VINEXT_PRERENDER;
+		else process.env.VINEXT_PRERENDER = previousPrerenderFlag;
+	}
+	if (allRoutes.length === 0) {
+		progress.finish(0, 0, 0);
+		return null;
+	}
+	let rendered = 0;
+	let skipped = 0;
+	let errors = 0;
+	for (const r of allRoutes) if (r.status === "rendered") rendered++;
+	else if (r.status === "skipped") skipped++;
+	else errors++;
+	try {
+		fs.mkdirSync(manifestDir, { recursive: true });
+		writePrerenderIndex(allRoutes, manifestDir, {
+			buildId: config.buildId,
+			trailingSlash: config.trailingSlash
+		});
+	} finally {
+		progress.finish(rendered, skipped, errors);
+	}
+	assertNoFatalPrerenderRoutes(allRoutes);
+	if (mode === "export" && errors > 0) {
+		const errorRoutes = allRoutes.filter((r) => r.status === "error").map((r) => `  ${r.route}: ${r.error}`).join("\n");
+		throw new Error(`Static export failed: ${errors} route${errors !== 1 ? "s" : ""} cannot be statically exported.\n${errorRoutes}\n\nRemove server-side data fetching (getServerSideProps, force-dynamic, revalidate) from these routes, or remove \`output: "export"\` from next.config.js.`);
+	}
+	return {
+		routes: allRoutes,
+		...allOutputFiles.length > 0 ? { outputFiles: allOutputFiles } : {}
+	};
+}
+//#endregion
+export { assertNoFatalPrerenderRoutes, runPrerender };

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

@@ -0,0 +1,18 @@
+//#region src/build/server-manifest.d.ts
+/**
+ * Shared utilities for reading/writing vinext-server.json.
+ *
+ * Kept in a separate file so both build-time code (prerender.ts) and
+ * runtime code (prod-server.ts) can import it without creating a circular
+ * dependency.
+ */
+/**
+ * Read the prerender secret from `vinext-server.json` in `serverDir`.
+ *
+ * Returns `undefined` if the file does not exist or cannot be parsed.
+ * Callers that require a secret (i.e. the prerender phase itself) should
+ * warn when this returns `undefined`.
+ */
+declare function readPrerenderSecret(serverDir: string): string | undefined;
+//#endregion
+export { readPrerenderSecret };

package/dist/build/server-manifest.js

@@ -0,0 +1,22 @@
+import { readJsonFile } from "../utils/safe-json-file.js";
+import path from "node:path";
+//#region src/build/server-manifest.ts
+/**
+* Shared utilities for reading/writing vinext-server.json.
+*
+* Kept in a separate file so both build-time code (prerender.ts) and
+* runtime code (prod-server.ts) can import it without creating a circular
+* dependency.
+*/
+/**
+* Read the prerender secret from `vinext-server.json` in `serverDir`.
+*
+* Returns `undefined` if the file does not exist or cannot be parsed.
+* Callers that require a secret (i.e. the prerender phase itself) should
+* warn when this returns `undefined`.
+*/
+function readPrerenderSecret(serverDir) {
+	return readJsonFile(path.join(serverDir, "vinext-server.json"))?.prerenderSecret;
+}
+//#endregion
+export { readPrerenderSecret };

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

@@ -0,0 +1,18 @@
+//#region src/build/ssr-manifest.d.ts
+type BundleBackfillChunk = {
+  type: "chunk";
+  fileName: string;
+  imports?: string[];
+  modules?: Record<string, unknown>;
+  viteMetadata?: {
+    importedCss?: Set<string>;
+    importedAssets?: Set<string>;
+  };
+};
+declare function tryRealpathSync(candidate: string): string | null;
+declare function relativeWithinRoot(root: string, moduleId: string): string | null;
+declare function augmentSsrManifestFromBundle(ssrManifest: Record<string, string[]>, bundle: Record<string, BundleBackfillChunk | {
+  type: string;
+}>, root: string, base?: string): Record<string, string[]>;
+//#endregion
+export { BundleBackfillChunk, augmentSsrManifestFromBundle, relativeWithinRoot, tryRealpathSync };

package/dist/build/ssr-manifest.js

@@ -0,0 +1,69 @@
+import { collapseDuplicateBase, manifestFileWithBase } from "../utils/manifest-paths.js";
+import fs from "node:fs";
+import path from "node:path";
+//#region src/build/ssr-manifest.ts
+function tryRealpathSync(candidate) {
+	try {
+		return fs.realpathSync.native(candidate);
+	} catch {
+		return null;
+	}
+}
+function isWindowsAbsolutePath(candidate) {
+	return /^[a-zA-Z]:[\\/]/.test(candidate) || candidate.startsWith("\\\\");
+}
+function relativeWithinRoot(root, moduleId) {
+	const relativeId = (isWindowsAbsolutePath(root) || isWindowsAbsolutePath(moduleId) ? path.win32.relative(root, moduleId) : path.relative(root, moduleId)).replace(/\\/g, "/");
+	if (!relativeId || relativeId === ".." || relativeId.startsWith("../")) return null;
+	return relativeId;
+}
+function normalizeManifestModuleId(moduleId, root) {
+	const normalizedId = moduleId.replace(/\\/g, "/");
+	if (normalizedId.startsWith("\0")) return normalizedId;
+	if (normalizedId.startsWith("node_modules/") || normalizedId.includes("/node_modules/")) return normalizedId;
+	if (!isWindowsAbsolutePath(moduleId) && !path.isAbsolute(moduleId)) {
+		if (!normalizedId.startsWith(".") && !normalizedId.includes("../")) return normalizedId;
+	}
+	const rootCandidates = new Set([root]);
+	const realRoot = tryRealpathSync(root);
+	if (realRoot) rootCandidates.add(realRoot);
+	const moduleCandidates = /* @__PURE__ */ new Set();
+	if (isWindowsAbsolutePath(moduleId) || path.isAbsolute(moduleId)) moduleCandidates.add(moduleId);
+	else moduleCandidates.add(path.resolve(root, moduleId));
+	for (const candidate of moduleCandidates) {
+		const realCandidate = tryRealpathSync(candidate);
+		if (realCandidate) moduleCandidates.add(realCandidate);
+	}
+	for (const rootCandidate of rootCandidates) for (const moduleCandidate of moduleCandidates) {
+		const relativeId = relativeWithinRoot(rootCandidate, moduleCandidate);
+		if (relativeId) return relativeId;
+	}
+	return normalizedId;
+}
+function augmentSsrManifestFromBundle(ssrManifest, bundle, root, base = "/") {
+	const nextManifest = {};
+	for (const [key, files] of Object.entries(ssrManifest)) {
+		const normalizedKey = normalizeManifestModuleId(key, root);
+		if (!nextManifest[normalizedKey]) nextManifest[normalizedKey] = /* @__PURE__ */ new Set();
+		for (const file of files) nextManifest[normalizedKey].add(collapseDuplicateBase(file, base));
+	}
+	for (const item of Object.values(bundle)) {
+		if (item.type !== "chunk") continue;
+		const chunk = item;
+		const files = /* @__PURE__ */ new Set();
+		files.add(manifestFileWithBase(chunk.fileName, base));
+		for (const importedFile of chunk.imports ?? []) files.add(manifestFileWithBase(importedFile, base));
+		for (const cssFile of chunk.viteMetadata?.importedCss ?? []) files.add(manifestFileWithBase(cssFile, base));
+		for (const assetFile of chunk.viteMetadata?.importedAssets ?? []) files.add(manifestFileWithBase(assetFile, base));
+		for (const moduleId of Object.keys(chunk.modules ?? {})) {
+			const key = normalizeManifestModuleId(moduleId, root);
+			if (key.startsWith("node_modules/") || key.includes("/node_modules/")) continue;
+			if (key.startsWith("\0")) continue;
+			if (!nextManifest[key]) nextManifest[key] = /* @__PURE__ */ new Set();
+			for (const file of files) nextManifest[key].add(file);
+		}
+	}
+	return Object.fromEntries(Object.entries(nextManifest).map(([key, files]) => [key, [...files]]));
+}
+//#endregion
+export { augmentSsrManifestFromBundle, relativeWithinRoot, tryRealpathSync };