vinext 1.0.0 → 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/THIRD_PARTY_LICENSES.md

@@ -23,3 +23,29 @@ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
+
+## dotenv (parser adapted from version 16.3.1)
+
+Copyright (c) 2015, Scott Motte
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+- Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+- Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

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/lifecycle.js

@@ -141,16 +141,6 @@ async function finalizeBuild(builder, context) {
 		__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,
@@ -187,6 +177,16 @@ async function finalizeBuild(builder, context) {
 			routeRootConfig: buildOutput
 		});
 	}
+	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 { printBuildReport } = await import("./report.js");
 	await printBuildReport({
 		root: context.root,

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

@@ -1,9 +1,14 @@
 import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
+import { getSharedChunkFiles } from "../server/pages-asset-tags.js";
 import fs from "node:fs";
 //#region src/build/pages-client-assets-module.ts
 const PAGES_CLIENT_ASSETS_MODULE = "vinext-client-assets.js";
 function buildPagesClientAssetsModule(assets) {
-	return `export default ${JSON.stringify(assets)};\n`;
+	const prepared = assets.ssrManifest ? {
+		...assets,
+		sharedChunks: getSharedChunkFiles(assets.ssrManifest)
+	} : assets;
+	return `export default ${JSON.stringify(prepared)};\n`;
 }
 function writePagesClientAssetsModuleIfMissing(outputDir, moduleSource) {
 	const outputPath = path.join(outputDir, PAGES_CLIENT_ASSETS_MODULE);

package/dist/build/precompress.js

@@ -3,9 +3,9 @@ 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";
+import { promisify } from "node:util";
 //#region src/build/precompress.ts
 /**
 * Build-time precompression for hashed static assets.

package/dist/build/prerender-paths.js

@@ -10,18 +10,19 @@ 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, resolveParentParams, routeStaticParamSets, validateDiscoveredParams } from "./prerender.js";
-import { collectAppPageStaticGenerationRuntimes, hasAppPageGenerateStaticParamsAtLastDynamicSegment, isAppPageStaticEligible, isEdgeRuntime, resolveAppPageDynamicConfig, resolveAppPageSegmentConfig, resolveAppPageStaticGenerationRuntime } from "../server/app-segment-config.js";
-import { resolveBuiltRscEntryPath } from "./server-entry.js";
+import { buildUrlFromParams, layoutOnlyParamSets, localizePagesPath, resolveParentParams, routeStaticParamSets, validateDiscoveredParams } from "./prerender.js";
+import { resolveBuiltPagesEntryPath, resolveBuiltRscEntryPath } from "./server-entry.js";
 import fs from "node:fs";
 //#region src/build/prerender-paths.ts
 const PRERENDER_PATH_DISCOVERY_ENV = "__VINEXT_PRERENDER_PATH_DISCOVERY";
@@ -325,10 +326,6 @@ async function resolvePagesWarmRouteMetadata(options) {
 		routePatterns
 	};
 }
-function localizePagesPath(pathname, locale, i18n) {
-	if (!i18n || !locale || locale === i18n.defaultLocale) return pathname;
-	return pathname === "/" ? `/${locale}` : `/${locale}${pathname}`;
-}
 /**
 * Next.js data URLs always carry the locale segment, including the default
 * locale that is omitted from the corresponding public HTML pathname.
@@ -355,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}`;
@@ -795,7 +716,7 @@ async function discoverPrerenderPathManifest(options) {
 	const rscBundlePath = options.rscBundlePath ?? defaultRscBundlePath;
 	const relativeRscEntryPath = path.relative(configuredRscServerDir, rscBundlePath);
 	const rscServerDir = !relativeRscEntryPath.startsWith("../") && !path.isAbsolute(relativeRscEntryPath) ? configuredRscServerDir : path.dirname(rscBundlePath);
-	const pagesBundlePath = options.pagesBundlePath ?? path.join(root, "dist", "server", "entry.js");
+	const pagesBundlePath = options.pagesBundlePath ?? resolveBuiltPagesEntryPath(path.resolve(root, options.routeRootConfig?.ssrOutDir ?? path.join("dist", "server")));
 	const bundleServerDir = fs.existsSync(rscBundlePath) ? rscServerDir : path.dirname(pagesBundlePath);
 	const manifestDir = path.join(root, "dist", "server");
 	const config = options.nextConfig ? { ...options.nextConfig } : { ...await resolveNextConfig(await loadNextConfig(root, PHASE_PRODUCTION_BUILD), root) };

package/dist/build/prerender.d.ts

@@ -30,8 +30,14 @@ export type PrerenderRouteResult = {
   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. */
+  /** Original HTTP status for prerendered route responses. */
   responseStatus?: number;
+  /** Pages source returned notFound, distinct from the custom 404 document. */
+  notFound?: true;
+  /** Original Pages redirect props, including client navigation semantics. */
+  redirectProps?: object;
+  /** Pages locale rendered for this public pathname. */
+  locale?: string;
   /** Cache tags collected while rendering this route. */
   tags?: string[];
   /** Raw app-tree segments used to derive App Route implicit tags. */
@@ -234,6 +240,7 @@ export declare function routeStaticParamSets(route: Pick<AppRoute, "pattern">, p
  * sets still go through routeStaticParamSets.
  */
 export declare function layoutOnlyParamSets(route: Pick<AppRoute, "params" | "pattern">, parentParamSets: Record<string, string | string[]>[]): Record<string, string | string[]>[] | null;
+export declare function localizePagesPath(pathname: string, locale: string | undefined, i18n: ResolvedNextConfig["i18n"]): string;
 /**
  * Run the prerender phase for Pages Router.
  *