vinext 1.0.0-beta.9 → 1.0.0

package/dist/build/lifecycle.js

@@ -0,0 +1,253 @@
+import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
+import { flattenPluginOptions } from "../utils/plugin-options.js";
+import { finalizeCacheAdapterPrerenderOutput, hasBuildIdentityResponseHeader, hasUncachedRequestRouting, hasVerbatimResponseVary, isConfiguredCdnResponsePolicyHeader } from "../cache/cache-adapters-virtual.js";
+import { formatVinextPrerenderLabel, resolveVinextPrerenderDecision } from "../config/prerender.js";
+import { resolveVinextPackageRoot } from "../utils/vinext-root.js";
+import { cleanBuildOutput } from "./clean-output.js";
+import { PAGES_CLIENT_ASSETS_MODULE } from "./pages-client-assets-module.js";
+import { runWithPreviewBuildCredentials } from "./preview-credentials.js";
+import { createRequire } from "node:module";
+import fs from "node:fs";
+import { pathToFileURL } from "node:url";
+//#region src/build/lifecycle.ts
+const VINEXT_BUILD_LIFECYCLE_CONFIG = "__vinextBuildLifecycle";
+async function loadProjectViteApi(root) {
+	let vitePath;
+	try {
+		vitePath = createRequire(path.join(root, "package.json")).resolve("vite");
+	} catch {
+		vitePath = "vite";
+	}
+	return await (vitePath === "vite" ? import(vitePath) : import(pathToFileURL(vitePath).href));
+}
+function restoreEnvironment(previous) {
+	for (const [key, value] of previous) if (value === void 0) delete process.env[key];
+	else process.env[key] = value;
+}
+async function withEnvironment(values, callback) {
+	const previous = /* @__PURE__ */ new Map();
+	for (const [key, value] of Object.entries(values)) {
+		previous.set(key, process.env[key]);
+		if (value === void 0) delete process.env[key];
+		else process.env[key] = value;
+	}
+	try {
+		return await callback();
+	} finally {
+		restoreEnvironment(previous);
+	}
+}
+function isInternalBuildPlugin(plugin) {
+	return plugin.name.startsWith("vinext:") || plugin.name.startsWith("vite:react") || plugin.name === "rsc" || plugin.name.startsWith("rsc:") || plugin.name === "vite-rsc-load-module-dev-proxy" || plugin.name.startsWith("vite-plugin-cloudflare");
+}
+async function loadHybridUserConfig(root, mode, configFile, configNodeEnv) {
+	if (!configFile) return {};
+	const vite = await loadProjectViteApi(root);
+	const load = () => vite.loadConfigFromFile({
+		command: "build",
+		mode,
+		isSsrBuild: true
+	}, configFile, root);
+	const loaded = configNodeEnv ? await withEnvironment({ NODE_ENV: configNodeEnv }, load) : await load();
+	if (!loaded) return {};
+	const plugins = await flattenPluginOptions(loaded.config.plugins);
+	return {
+		...loaded.config,
+		plugins: plugins.filter((plugin) => Boolean(plugin) && typeof plugin.name === "string" && !isInternalBuildPlugin(plugin)).map((plugin) => ({
+			...plugin,
+			buildApp: void 0
+		}))
+	};
+}
+async function buildHybridPagesBundle(builder, context) {
+	const vite = await loadProjectViteApi(context.root);
+	const userConfig = await loadHybridUserConfig(context.root, builder.config.mode, builder.config.configFile, context.configNodeEnv);
+	if (builder.config.logLevel !== "silent") console.log("  Building Pages Router server (hybrid)...");
+	const userSsrEnvironment = userConfig.environments?.ssr;
+	const { build: _userSsrBuild, ...pagesEnvironment } = userSsrEnvironment ?? {};
+	const mergedBuild = vite.mergeConfig(userConfig.build ?? {}, userSsrEnvironment?.build ?? {});
+	const userOutput = mergedBuild.rolldownOptions?.output;
+	const appAssetsPath = path.resolve(context.root, builder.environments.rsc?.config.build.outDir ?? "dist/server", PAGES_CLIENT_ASSETS_MODULE);
+	const pagesClientAssetsModule = fs.existsSync(appAssetsPath) ? fs.readFileSync(appAssetsPath, "utf8") : null;
+	const pagesBuild = {
+		...mergedBuild,
+		outDir: "dist/server",
+		emptyOutDir: false,
+		manifest: false,
+		ssr: "virtual:vinext-server-entry",
+		rolldownOptions: {
+			...mergedBuild.rolldownOptions,
+			output: Array.isArray(userOutput) ? userOutput.map((output) => ({
+				...output,
+				entryFileNames: "entry.js"
+			})) : {
+				...userOutput,
+				entryFileNames: "entry.js"
+			}
+		}
+	};
+	const pagesConfig = {
+		...userConfig,
+		root: context.root,
+		mode: builder.config.mode,
+		configFile: false,
+		plugins: [...userConfig.plugins ?? [], ...context.createPagesOnlyPlugins(pagesClientAssetsModule)],
+		builder: {
+			...userConfig.builder,
+			buildApp: async (pagesBuilder) => {
+				await pagesBuilder.build(pagesBuilder.environments.ssr);
+			}
+		},
+		environments: { ssr: {
+			...pagesEnvironment,
+			consumer: "server"
+		} },
+		resolve: {
+			...userConfig.resolve,
+			dedupe: [
+				...userConfig.resolve?.dedupe ?? [],
+				"react",
+				"react-dom",
+				"react/jsx-runtime",
+				"react/jsx-dev-runtime"
+			]
+		},
+		customLogger: builder.config.logger,
+		build: pagesBuild
+	};
+	const createPagesBuilder = () => vite.createBuilder(pagesConfig);
+	await (context.configNodeEnv ? await withEnvironment({ NODE_ENV: context.configNodeEnv }, createPagesBuilder) : await createPagesBuilder()).buildApp();
+}
+function checkStandaloneBuildPrerequisite(context) {
+	if (!context.deferPostBuild && context.nextConfig.output === "standalone") {
+		const vinextDistDir = path.join(resolveVinextPackageRoot(), "dist");
+		if (!fs.existsSync(vinextDistDir)) throw new Error(`vinext dist/ not found at ${vinextDistDir}. Build the vinext package before creating standalone output.`);
+	}
+}
+function prepareBuildOutput(context, emptyOutDir = context.emptyOutDir) {
+	checkStandaloneBuildPrerequisite(context);
+	cleanBuildOutput({
+		root: context.root,
+		outDir: path.resolve(context.root, "dist"),
+		emptyOutDir
+	});
+}
+async function finalizeBuild(builder, context) {
+	if (context.hasAppDir && context.hasPagesDir && !context.skipHybridPagesBundle) await withEnvironment({
+		__VINEXT_SHARED_BUILD_ID: context.nextConfig.buildId,
+		__VINEXT_SHARED_PRERENDER_SECRET: context.prerenderSecret,
+		__VINEXT_SHARED_REVALIDATE_SECRET: context.revalidateSecret,
+		__VINEXT_SHARED_RSC_BUILD_IDENTITY: context.rscBuildIdentity,
+		__VINEXT_SHARED_RSC_COMPATIBILITY_ID: context.rscCompatibilityId
+	}, () => runWithPreviewBuildCredentials(() => buildHybridPagesBundle(builder, context), context.previewBuildCredentials));
+	if (context.deferPostBuild) return;
+	if (context.nextConfig.output === "standalone") {
+		const { emitStandaloneOutput } = await import("./standalone.js");
+		const standalone = emitStandaloneOutput({
+			root: context.root,
+			outDir: path.resolve(context.root, "dist")
+		});
+		console.log(`  Generated standalone output in ${path.relative(context.root, standalone.standaloneDir)}/`);
+		console.log("  Start it with: node dist/standalone/server.js\n");
+		return;
+	}
+	const prerenderDecision = resolveVinextPrerenderDecision({
+		prerenderAllFlag: context.prerenderAll,
+		vinextPrerenderConfig: context.prerenderConfig,
+		nextOutput: context.nextConfig.output
+	});
+	const buildOutput = {
+		...context.routeRootConfig,
+		rscOutDir: builder.environments.rsc?.config.build.outDir ?? context.routeRootConfig?.rscOutDir,
+		ssrOutDir: builder.environments.ssr?.config.build.outDir ?? context.routeRootConfig?.ssrOutDir,
+		clientOutDir: builder.environments.client?.config.build.outDir ?? context.routeRootConfig?.clientOutDir
+	};
+	let prerenderResult;
+	if (prerenderDecision) {
+		if (context.nextConfig.enablePrerenderSourceMaps) {
+			process.setSourceMapsEnabled(true);
+			Error.stackTraceLimit = Math.max(Error.stackTraceLimit, 50);
+		}
+		console.log(`  ${formatVinextPrerenderLabel(prerenderDecision)}`);
+		const [{ emitPrerenderPathManifest }, { runPrerender }] = await Promise.all([import("./prerender-paths.js"), import("./run-prerender.js")]);
+		prerenderResult = await runPrerender({
+			root: context.root,
+			concurrency: context.prerenderConcurrency,
+			nextConfig: context.nextConfig,
+			routeRootConfig: buildOutput
+		});
+		if (context.nextConfig.output !== "export") await finalizeCacheAdapterPrerenderOutput(context.cacheConfig, context.root, { clientOutDir: buildOutput.clientOutDir });
+		await emitPrerenderPathManifest({
+			root: context.root,
+			nextConfig: context.nextConfig,
+			buildIdentity: hasBuildIdentityResponseHeader(context.cacheConfig) ? "response-header" : void 0,
+			responseVary: hasVerbatimResponseVary(context.cacheConfig) ? "verbatim" : void 0,
+			requestRouting: hasUncachedRequestRouting(context.cacheConfig) ? "uncached-stage" : void 0,
+			isResponsePolicyHeader: (name) => isConfiguredCdnResponsePolicyHeader(context.cacheConfig, name),
+			routeRootConfig: buildOutput
+		});
+	}
+	const { printBuildReport } = await import("./report.js");
+	await printBuildReport({
+		root: context.root,
+		pageExtensions: context.nextConfig.pageExtensions,
+		prerenderResult: prerenderResult ?? void 0
+	});
+	console.log("\n  Build complete.\n");
+}
+function createBuildLifecyclePlugins(options) {
+	let outputPrepared = false;
+	const createContext = () => ({
+		...options.createContext(),
+		deferPostBuild: options.shouldDeferPostBuild?.()
+	});
+	const finalizePlugin = {
+		name: "vinext:build-lifecycle-finalize",
+		apply: "build",
+		enforce: "post",
+		configResolved: {
+			order: "post",
+			handler(config) {
+				const plugins = config.plugins;
+				const index = plugins.indexOf(finalizePlugin);
+				if (index !== -1 && index !== plugins.length - 1) plugins.push(...plugins.splice(index, 1));
+			}
+		},
+		buildApp: {
+			order: "post",
+			async handler(builder) {
+				if (!options.isEnabled(builder)) return;
+				await finalizeBuild(builder, createContext());
+				options.onComplete?.();
+			}
+		}
+	};
+	return [{
+		name: "vinext:build-lifecycle-prepare",
+		apply: "build",
+		configResolved: {
+			order: "pre",
+			handler(config) {
+				if (outputPrepared || !options.shouldPrepare(config)) return;
+				const context = createContext();
+				if (config.build.emptyOutDir === false) context.emptyOutDir = false;
+				checkStandaloneBuildPrerequisite(context);
+				options.onPrepare?.();
+				prepareBuildOutput(context);
+				outputPrepared = true;
+			}
+		},
+		buildApp: {
+			order: "pre",
+			async handler(builder) {
+				if (!options.isEnabled(builder) || !options.shouldBuildPlainPages()) return;
+				for (const name of ["client", "ssr"]) {
+					const environment = builder.environments[name];
+					if (environment && !environment.isBuilt) await builder.build(environment);
+				}
+			}
+		}
+	}, finalizePlugin];
+}
+//#endregion
+export { VINEXT_BUILD_LIFECYCLE_CONFIG, createBuildLifecyclePlugins, prepareBuildOutput };

package/dist/build/module-dependency-cache.d.ts

@@ -1,4 +1,3 @@
 //#region src/build/module-dependency-cache.d.ts
-declare function createModuleDependencyCache<T>(collect: (moduleId: string) => Promise<T>): (moduleId: string) => Promise<T>;
-//#endregion
-export { createModuleDependencyCache };
+export declare function createModuleDependencyCache<T>(collect: (moduleId: string) => Promise<T>): (moduleId: string) => Promise<T>;
+//#endregion

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

@@ -6,8 +6,7 @@ type EmitNextClientRuntimeManifestsOptions = {
   buildId: string;
   rewrites: ResolvedNextConfig["rewrites"];
 };
-declare function buildNextClientBuildManifestContent(rewrites: ResolvedNextConfig["rewrites"]): string;
-declare function buildNextClientSsgManifestContent(): string;
-declare function emitNextClientRuntimeManifests(options: EmitNextClientRuntimeManifestsOptions): void;
-//#endregion
-export { buildNextClientBuildManifestContent, buildNextClientSsgManifestContent, emitNextClientRuntimeManifests };
+export declare function buildNextClientBuildManifestContent(rewrites: ResolvedNextConfig["rewrites"]): string;
+export declare function buildNextClientSsgManifestContent(): string;
+export declare function emitNextClientRuntimeManifests(options: EmitNextClientRuntimeManifestsOptions): void;
+//#endregion

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

@@ -1,6 +1,6 @@
 import { RouteRow } from "./report.js";
 //#region src/build/nitro-route-rules.d.ts
-type NitroRouteRuleConfig = Record<string, unknown> & {
+export type NitroRouteRuleConfig = Record<string, unknown> & {
   swr?: boolean | number;
   cache?: unknown;
   static?: boolean;
@@ -22,12 +22,12 @@ type NitroRouteRules = Record<string, {
  * classified as `unknown` by static analysis (which `printBuildReport` might upgrade
  * to `static` via speculative prerender) are skipped here.
  */
-declare function collectNitroRouteRules(options: {
+export declare function collectNitroRouteRules(options: {
   appDir?: string | null;
   pagesDir?: string | null;
   pageExtensions: string[];
 }): Promise<NitroRouteRules>;
-declare function generateNitroRouteRules(rows: RouteRow[]): NitroRouteRules;
+export declare function generateNitroRouteRules(rows: RouteRow[]): NitroRouteRules;
 /**
  * Converts vinext's internal `:param` route syntax to Nitro's rou3
  * pattern format. Nitro uses `rou3` for routeRules matching, which
@@ -39,10 +39,9 @@ declare function generateNitroRouteRules(rows: RouteRow[]): NitroRouteRules;
  *   /about        -> /about    (unchanged)
  *   /:a/:b produces `/*`/`/*` (consecutive single-segment params)
  */
-declare function convertToNitroPattern(pattern: string): string;
-declare function mergeNitroRouteRules(existingRouteRules: Record<string, NitroRouteRuleConfig> | undefined, generatedRouteRules: NitroRouteRules): {
+export declare function convertToNitroPattern(pattern: string): string;
+export declare function mergeNitroRouteRules(existingRouteRules: Record<string, NitroRouteRuleConfig> | undefined, generatedRouteRules: NitroRouteRules): {
   routeRules: Record<string, NitroRouteRuleConfig>;
   skippedRoutes: string[];
 };
-//#endregion
-export { NitroRouteRuleConfig, collectNitroRouteRules, convertToNitroPattern, generateNitroRouteRules, mergeNitroRouteRules };
+//#endregion

package/dist/build/nitro-route-rules.js

@@ -1,6 +1,6 @@
+import { appRouter } from "../routing/app-router.js";
 import { apiRouter, pagesRouter } from "../routing/pages-router.js";
 import { buildReportRows } from "./report.js";
-import { appRouter } from "../routing/app-router.js";
 //#region src/build/nitro-route-rules.ts
 /**
 * Scans the filesystem for route files and generates Nitro `routeRules` for ISR routes.

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

@@ -1,10 +1,6 @@
 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;
-declare function writePagesClientAssetsModuleIfMissing(outputDir: string, moduleSource: string): void;
-declare function setPagesClientAssetsBuildMetadata(buildSession: string, moduleSource: string): void;
-declare function takePagesClientAssetsBuildMetadata(buildSession: string): string | null;
-declare function clearPagesClientAssetsBuildMetadata(buildSession: string): void;
-//#endregion
-export { PAGES_CLIENT_ASSETS_MODULE, buildPagesClientAssetsModule, clearPagesClientAssetsBuildMetadata, setPagesClientAssetsBuildMetadata, takePagesClientAssetsBuildMetadata, writePagesClientAssetsModuleIfMissing };
+export declare const PAGES_CLIENT_ASSETS_MODULE = "vinext-client-assets.js";
+export declare function buildPagesClientAssetsModule(assets: PagesClientAssets): string;
+export declare function writePagesClientAssetsModuleIfMissing(outputDir: string, moduleSource: string): void;
+//#endregion

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

@@ -2,7 +2,6 @@ import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 import fs from "node:fs";
 //#region src/build/pages-client-assets-module.ts
 const PAGES_CLIENT_ASSETS_MODULE = "vinext-client-assets.js";
-const pagesClientAssetsByBuildSession = /* @__PURE__ */ new Map();
 function buildPagesClientAssetsModule(assets) {
 	return `export default ${JSON.stringify(assets)};\n`;
 }
@@ -12,16 +11,5 @@ function writePagesClientAssetsModuleIfMissing(outputDir, moduleSource) {
 	fs.mkdirSync(outputDir, { recursive: true });
 	fs.writeFileSync(outputPath, moduleSource);
 }
-function setPagesClientAssetsBuildMetadata(buildSession, moduleSource) {
-	pagesClientAssetsByBuildSession.set(buildSession, moduleSource);
-}
-function takePagesClientAssetsBuildMetadata(buildSession) {
-	const moduleSource = pagesClientAssetsByBuildSession.get(buildSession) ?? null;
-	pagesClientAssetsByBuildSession.delete(buildSession);
-	return moduleSource;
-}
-function clearPagesClientAssetsBuildMetadata(buildSession) {
-	pagesClientAssetsByBuildSession.delete(buildSession);
-}
 //#endregion
-export { PAGES_CLIENT_ASSETS_MODULE, buildPagesClientAssetsModule, clearPagesClientAssetsBuildMetadata, setPagesClientAssetsBuildMetadata, takePagesClientAssetsBuildMetadata, writePagesClientAssetsModuleIfMissing };
+export { PAGES_CLIENT_ASSETS_MODULE, buildPagesClientAssetsModule, writePagesClientAssetsModuleIfMissing };

package/dist/build/precompress.d.ts

@@ -23,10 +23,9 @@ type PrecompressResult = {
  * `assetPrefix` builds would walk an empty `_next/static/` directory and
  * emit zero compressed variants.
  */
-declare function precompressAssets(clientDir: string, options?: {
+export declare function precompressAssets(clientDir: string, options?: {
   /** Subdirectory under `clientDir` containing hashed assets. Defaults to `"_next/static"`. */
   assetsDir?: string;
   onProgress?: (completed: number, total: number, file: string) => void;
 }): Promise<PrecompressResult>;
-//#endregion
-export { precompressAssets };
+//#endregion

package/dist/build/prerender-cloudflare-loader.d.ts

@@ -0,0 +1,4 @@
+//#region src/build/prerender-cloudflare-loader.d.ts
+/** Allow Node's prerender runner to import the Worker bundle without granting Worker bindings. */
+export declare function registerPrerenderCloudflareLoader(): void;
+//#endregion

package/dist/build/prerender-cloudflare-loader.js

@@ -0,0 +1,49 @@
+import { register } from "node:module";
+//#region src/build/prerender-cloudflare-loader.ts
+let registered = false;
+/** Allow Node's prerender runner to import the Worker bundle without granting Worker bindings. */
+function registerPrerenderCloudflareLoader() {
+	if (registered) return;
+	registered = true;
+	register(`data:text/javascript,${encodeURIComponent(`
+      export async function resolve(specifier, context, nextResolve) {
+        if (specifier === "cloudflare:workers") {
+          return { shortCircuit: true, url: ${JSON.stringify(`data:text/javascript,${encodeURIComponent(`
+    export const tracing = undefined;
+    function unavailable() {
+      throw new Error("Cloudflare bindings are unavailable during build-time prerendering. Use cache warming for binding-dependent routes.");
+    }
+    const inaccessible = new Proxy({}, {
+      get: unavailable,
+      has: unavailable,
+      ownKeys: unavailable,
+      getOwnPropertyDescriptor: unavailable,
+    });
+    export const env = inaccessible;
+    export const exports = inaccessible;
+    export const cache = inaccessible;
+    export class WorkerEntrypoint { constructor() { unavailable(); } }
+    export class DurableObject { constructor() { unavailable(); } }
+    export class RpcTarget { constructor() { unavailable(); } }
+    export class RpcPromise { constructor() { unavailable(); } }
+    export class RpcProperty { constructor() { unavailable(); } }
+    export class ServiceStub { constructor() { unavailable(); } }
+    export class WorkflowEntrypoint { constructor() { unavailable(); } }
+    export class WorkflowStep { constructor() { unavailable(); } }
+    export function RpcStub() { unavailable(); }
+    export function restore() { unavailable(); }
+    export function abortIsolate() { unavailable(); }
+    export function withEnv() { unavailable(); }
+    export function withExports() { unavailable(); }
+    export function withEnvAndExports() { unavailable(); }
+    export function waitUntil() {
+      throw new Error("Cloudflare waitUntil is unavailable during build-time prerendering.");
+    }
+  `)}`)} };
+        }
+        return nextResolve(specifier, context);
+      }
+    `)}`);
+}
+//#endregion
+export { registerPrerenderCloudflareLoader };

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

@@ -1,8 +1,9 @@
-import { ResolvedNextConfig } from "../config/next-config.js";
 import { CdnCacheAdapterCapabilities } from "../cache/cache-adapters-virtual.js";
 import { VinextRouteRootConfig } from "../config/prerender.js";
+import { ResolvedNextConfig } from "../config/next-config.js";
+import { MatcherConfig } from "../server/middleware-matcher.js";
 //#region src/build/prerender-paths.d.ts
-type PrerenderRoutePattern = {
+export type PrerenderRoutePattern = {
   kind: "app-page" | "app-route" | "pages-page";
   pattern: string;
   /** Closed-world safety facts for probe coordinator optimizations. */
@@ -10,9 +11,21 @@ type PrerenderRoutePattern = {
     canPrunePattern: boolean;
     /** HTML pathname shared by alternate representations of this route. */
     concretePathname?: string;
+    /** The uncached request stage may resolve this public path to another route. */
+    routeMayResolve?: boolean;
+    /** A request representation may terminate before reaching the response stage. */
+    requestStageMayTerminate?: boolean;
+    /**
+     * Not listed by the route's own static generation (`generateStaticParams`,
+     * `getStaticPaths` or a route without dynamic segments): picked from
+     * traffic, or, for an App page route, not listed by this route itself,
+     * which includes a route that isn't static or SSG and a path another
+     * route generates. A path both listed and picked counts as listed.
+     */
+    unlisted?: boolean;
   };
 };
-type PrerenderPathManifest = {
+export type PrerenderPathManifest = {
   /** App Page HTML paths after hybrid route ownership has been resolved. */
   appPaths?: string[];
   basePath?: string;
@@ -29,6 +42,8 @@ type PrerenderPathManifest = {
   routeHandlerPaths?: string[];
   /** App Router paths with an ordinary main-tree loading boundary. */
   loadingShellPaths?: string[];
+  /** Every App page route pattern with an ordinary main-tree loading boundary. */
+  loadingBoundaryRoutePatterns?: string[];
   /** Pages Router paths selected by the existing HTML warm discovery pass. */
   pagesPaths?: string[];
   /** Pages Router JSON data identities corresponding to discovered static paths. */
@@ -42,12 +57,16 @@ type PrerenderPathManifest = {
   trailingSlash?: boolean;
   paths: string[];
 };
-declare const PRERENDER_PATH_DISCOVERY_ENV = "__VINEXT_PRERENDER_PATH_DISCOVERY";
-declare const PRERENDER_PATHS_MANIFEST = "vinext-prerender-paths.json";
-declare const DEFAULT_REMOTE_PATH_DISCOVERY_RETRY_DELAY_MS = 1000;
-declare const DEFAULT_REMOTE_PATH_DISCOVERY_PHASE_TIMEOUT_MS = 120000;
-type EmitPrerenderPathManifestOptions = {
+export declare const PRERENDER_PATH_DISCOVERY_ENV = "__VINEXT_PRERENDER_PATH_DISCOVERY";
+export declare const PRERENDER_PATHS_MANIFEST = "vinext-prerender-paths.json";
+export declare const DEFAULT_REMOTE_PATH_DISCOVERY_RETRY_DELAY_MS = 1000;
+export declare const DEFAULT_REMOTE_PATH_DISCOVERY_PHASE_TIMEOUT_MS = 120000;
+type PrerenderPathDiscoveryOptions = {
   root: string;
+  /** Additional concrete public paths to resolve through the route graph. */
+  candidatePaths?: readonly string[];
+  /** Resolve only candidate paths instead of enumerating dynamic route hooks. */
+  candidatePathsOnly?: boolean;
   /** Fully resolved Next.js config. Loaded from disk when omitted. */
   nextConfig?: ResolvedNextConfig;
   appDir?: string | null;
@@ -57,6 +76,10 @@ type EmitPrerenderPathManifestOptions = {
   rscBundlePath?: string;
   buildIdentity?: CdnCacheAdapterCapabilities["buildIdentity"];
   responseVary?: CdnCacheAdapterCapabilities["responseVary"];
+  requestRouting?: CdnCacheAdapterCapabilities["requestRouting"];
+  isResponsePolicyHeader?: CdnCacheAdapterCapabilities["isResponsePolicyHeader"];
+  /** Include canonical RSC identities without claiming support for arbitrary Vary fields. */
+  includeCanonicalRsc?: boolean;
   /** Execute dynamic path hooks against an already-uploaded Worker. */
   pathDiscoveryTarget?: {
     baseUrl: string;
@@ -67,6 +90,8 @@ type EmitPrerenderPathManifestOptions = {
     retryDelayMs?: number;
   };
 };
-declare function emitPrerenderPathManifest(options: EmitPrerenderPathManifestOptions): Promise<PrerenderPathManifest | null>;
-//#endregion
-export { DEFAULT_REMOTE_PATH_DISCOVERY_PHASE_TIMEOUT_MS, DEFAULT_REMOTE_PATH_DISCOVERY_RETRY_DELAY_MS, PRERENDER_PATHS_MANIFEST, PRERENDER_PATH_DISCOVERY_ENV, PrerenderPathManifest, PrerenderRoutePattern, emitPrerenderPathManifest };
+/** @internal Match the pathname forms and locale provenance used by middleware runtime. */
+export declare function matchesMiddlewareWarmPath(pathname: string, matcher: MatcherConfig | undefined, i18n: ResolvedNextConfig["i18n"]): boolean;
+export declare function discoverPrerenderPathManifest(options: PrerenderPathDiscoveryOptions): Promise<PrerenderPathManifest | null>;
+export declare function emitPrerenderPathManifest(options: PrerenderPathDiscoveryOptions): Promise<PrerenderPathManifest | null>;
+//#endregion