vinext 1.0.0-beta.9 → 1.0.0

package/dist/routing/app-router.js

@@ -1,6 +1,6 @@
 import { createValidFileMatcher } from "./file-matcher.js";
-import { createRouteTrieCache, matchRouteWithTrie } from "./route-matching.js";
 import { buildAppRouteGraph, computeAppRouteStaticSiblings, computeRootParamNames, convertSegmentsToRouteParts } from "./app-route-graph.js";
+import { createRouteTrieCache, matchRouteWithTrie } from "./route-matching.js";
 //#region src/routing/app-router.ts
 /**
 * App Router file-system routing.
@@ -58,6 +58,28 @@ async function appRouter(appDir, pageExtensions, matcher) {
 function appRouteHasMainTreeLoadingBoundary(route) {
 	return route.loadingPath != null || (route.loadingPaths?.some((_loadingPath, index) => (route.loadingTreePositions?.[index] ?? 0) > 0) ?? false);
 }
+/**
+* A route's layouts below a dynamic URL segment, one generateStaticParams
+* provider each, keyed by the layout's directory. Next.js composes only the
+* segments of a route's own loader tree, each segment as its own step
+* (build/static-paths/app.ts generateRouteStaticParams), and route groups put
+* different layouts at the same URL pattern prefix, so neither the pattern nor
+* a shared provider identifies a layout.
+*/
+function appRouteLayoutStaticParamsGroups(route) {
+	const groups = [];
+	for (const [index, layoutPath] of route.layouts.entries()) {
+		const segments = route.routeSegments.slice(0, route.layoutTreePositions[index] ?? 0);
+		const pattern = `/${(convertSegmentsToRouteParts(segments)?.urlSegments ?? []).join("/")}`;
+		if (!pattern.includes(":")) continue;
+		groups.push({
+			key: `layouts:${segments.join("/")}`,
+			layoutPath,
+			pattern
+		});
+	}
+	return groups;
+}
 const appTrieCache = createRouteTrieCache();
 /**
 * Match a URL against App Router routes.
@@ -66,4 +88,4 @@ function matchAppRoute(url, routes) {
 	return matchRouteWithTrie(url, routes, appTrieCache);
 }
 //#endregion
-export { appRouteGraph, appRouteHasMainTreeLoadingBoundary, appRouter, computeAppRouteStaticSiblings, computeRootParamNames, convertSegmentsToRouteParts, invalidateAppRouteCache, matchAppRoute };
+export { appRouteGraph, appRouteHasMainTreeLoadingBoundary, appRouteLayoutStaticParamsGroups, appRouter, computeAppRouteStaticSiblings, computeRootParamNames, convertSegmentsToRouteParts, invalidateAppRouteCache, matchAppRoute };

package/dist/routing/file-matcher.d.ts

@@ -1,6 +1,6 @@
 //#region src/routing/file-matcher.d.ts
-declare function normalizePageExtensions(pageExtensions?: readonly string[] | null): string[];
-type ValidFileMatcher = {
+export declare function normalizePageExtensions(pageExtensions?: readonly string[] | null): string[];
+export type ValidFileMatcher = {
   extensions: string[];
   dottedExtensions: string[];
   extensionRegex: RegExp;
@@ -15,14 +15,14 @@ type ValidFileMatcher = {
  * Ported in spirit from Next.js createValidFileMatcher:
  * packages/next/src/server/lib/find-page-file.ts
  */
-declare function createValidFileMatcher(pageExtensions?: readonly string[] | null): ValidFileMatcher;
+export declare function createValidFileMatcher(pageExtensions?: readonly string[] | null): ValidFileMatcher;
 /** Check if a file exists with any configured page extension. */
-declare function findFileWithExtensions(basePath: string, matcher: ValidFileMatcher): boolean;
+export declare function findFileWithExtensions(basePath: string, matcher: ValidFileMatcher): boolean;
 /**
  * Find a file by basename and configured page extension in a directory.
  * Returns the first matching absolute path, or null if not found.
  */
-declare function findFileWithExts(dir: string, name: string, matcher: ValidFileMatcher): string | null;
+export declare function findFileWithExts(dir: string, name: string, matcher: ValidFileMatcher): string | null;
 /**
  * Add the config extensions produced by `vinext init` to vinext's resolver.
  *
@@ -38,7 +38,7 @@ declare function findFileWithExts(dir: string, name: string, matcher: ValidFileM
  * `.cjs`/`.cts` go last because `vinext init` renames CJS config files when it
  * adds `"type": "module"`, and app code may import those files extensionlessly.
  */
-declare function buildViteResolveExtensions(viteExtensions?: readonly string[]): string[];
+export declare function buildViteResolveExtensions(viteExtensions?: readonly string[]): string[];
 /**
  * Normalize an explicit Next.js resolver extension list for Vite.
  *
@@ -47,7 +47,7 @@ declare function buildViteResolveExtensions(viteExtensions?: readonly string[]):
  * webpack/Turbopack convention for trying the import exactly as written; Vite
  * already does that before appending extensions, so it must be omitted here.
  */
-declare function normalizeViteResolveExtensions(extensions: readonly string[]): string[];
+export declare function normalizeViteResolveExtensions(extensions: readonly string[]): string[];
 /**
  * Use function-form exclude for Node < 22.14 compatibility.
  *
@@ -55,6 +55,5 @@ declare function normalizeViteResolveExtensions(extensions: readonly string[]):
  * separators on Windows, so each match goes through `toSlash` — this is the
  * boundary where external fs output enters the canonical forward-slash space.
  */
-declare function scanWithExtensions(stem: string, cwd: string, extensions: readonly string[], exclude?: (name: string) => boolean): AsyncGenerator<string>;
-//#endregion
-export { ValidFileMatcher, buildViteResolveExtensions, createValidFileMatcher, findFileWithExtensions, findFileWithExts, normalizePageExtensions, normalizeViteResolveExtensions, scanWithExtensions };
+export declare function scanWithExtensions(stem: string, cwd: string, extensions: readonly string[], exclude?: (name: string) => boolean): AsyncGenerator<string>;
+//#endregion

package/dist/routing/pages-router.d.ts

@@ -1,7 +1,7 @@
 import { ValidFileMatcher } from "./file-matcher.js";
 import { patternToNextFormat } from "./route-validation.js";
 //#region src/routing/pages-router.d.ts
-type Route = {
+export type Route = {
   /** URL pattern, e.g. "/" or "/about" or "/posts/:id" */
   pattern: string;
   /** Pre-split pattern segments (computed once at scan time, reused per request) */
@@ -17,7 +17,7 @@ type Route = {
  * Invalidate cached routes for a given pages directory.
  * Called by the file watcher when pages are added/removed.
  */
-declare function invalidateRouteCache(pagesDir: string): void;
+export declare function invalidateRouteCache(pagesDir: string): void;
 /**
  * Scan the pages/ directory and return a list of routes.
  * Results are cached — call invalidateRouteCache() when files change.
@@ -30,12 +30,12 @@ declare function invalidateRouteCache(pagesDir: string): void;
  * - Ignores _app.tsx, _document.tsx, _error.tsx (Next.js special files)
  * - Ignores pages/api/ (handled separately later)
  */
-declare function pagesRouter(pagesDir: string, pageExtensions?: readonly string[], matcher?: ValidFileMatcher): Promise<Route[]>;
+export declare function pagesRouter(pagesDir: string, pageExtensions?: readonly string[], matcher?: ValidFileMatcher): Promise<Route[]>;
 /**
  * Match a URL path against a route pattern.
  * Returns the matched params or null if no match.
  */
-declare function matchRoute(url: string, routes: Route[]): {
+export declare function matchRoute(url: string, routes: Route[]): {
   route: Route;
   params: Record<string, string | string[]>;
 } | null;
@@ -47,6 +47,6 @@ declare function matchRoute(url: string, routes: Route[]): {
  * - pages/api/hello.ts -> /api/hello
  * - pages/api/users/[id].ts -> /api/users/:id
  */
-declare function apiRouter(pagesDir: string, pageExtensions?: readonly string[], matcher?: ValidFileMatcher): Promise<Route[]>;
+export declare function apiRouter(pagesDir: string, pageExtensions?: readonly string[], matcher?: ValidFileMatcher): Promise<Route[]>;
 //#endregion
-export { Route, apiRouter, invalidateRouteCache, matchRoute, pagesRouter, patternToNextFormat };
+export { patternToNextFormat };

package/dist/routing/pages-router.js

@@ -1,6 +1,6 @@
 import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
-import { decodeRouteSegment, sortRoutes } from "./utils.js";
 import { createValidFileMatcher, scanWithExtensions } from "./file-matcher.js";
+import { decodeRouteSegment, sortRoutes } from "./utils.js";
 import { patternToNextFormat, validateRoutePatterns } from "./route-validation.js";
 import { createRouteTrieCache, matchRouteWithTrieRawPathname } from "./route-matching.js";
 //#region src/routing/pages-router.ts

package/dist/routing/route-matching.d.ts

@@ -3,7 +3,7 @@ import { TrieNode } from "./route-trie.js";
 type RouteTrieCache<R extends {
   patternParts: string[];
 }> = WeakMap<R[], TrieNode<R>>;
-declare function createRouteTrieCache<R extends {
+export declare function createRouteTrieCache<R extends {
   patternParts: string[];
 }>(): RouteTrieCache<R>;
 /**
@@ -16,7 +16,7 @@ declare function createRouteTrieCache<R extends {
  * Generic over the route shape; both Pages `Route` and App `AppRoute`
  * satisfy `{ patternParts: string[] }`.
  */
-declare function matchRouteWithTrie<R extends {
+export declare function matchRouteWithTrie<R extends {
   patternParts: string[];
 }>(url: string, routes: R[], cache: RouteTrieCache<R>): {
   route: R;
@@ -29,11 +29,10 @@ declare function matchRouteWithTrie<R extends {
  * not select the filesystem route `/about`. Dynamic captures are still decoded
  * exactly once by `trieMatch`, matching `getRouteMatcher` upstream.
  */
-declare function matchRouteWithTrieRawPathname<R extends {
+export declare function matchRouteWithTrieRawPathname<R extends {
   patternParts: string[];
 }>(url: string, routes: R[], cache: RouteTrieCache<R>): {
   route: R;
   params: Record<string, string | string[]>;
 } | null;
-//#endregion
-export { createRouteTrieCache, matchRouteWithTrie, matchRouteWithTrieRawPathname };
+//#endregion

package/dist/routing/route-matching.js

@@ -36,7 +36,8 @@ function matchRouteWithTrie(url, routes, cache) {
 	let normalizedUrl = pathname === "/" ? "/" : pathname.replace(/\/$/, "");
 	normalizedUrl = normalizePathnameForRouteMatch(normalizedUrl);
 	const urlParts = normalizedUrl.split("/").filter(Boolean);
-	return trieMatch(getOrBuildTrie(cache, routes), urlParts);
+	const trie = getOrBuildTrie(cache, routes);
+	return trieMatch(trie, urlParts);
 }
 /**
 * Match a filesystem route against the request's raw encoded pathname.
@@ -48,7 +49,8 @@ function matchRouteWithTrie(url, routes, cache) {
 function matchRouteWithTrieRawPathname(url, routes, cache) {
 	const pathname = url.split("?")[0];
 	const urlParts = (pathname === "/" ? "/" : pathname.replace(/\/$/, "")).split("/").filter(Boolean);
-	return trieMatch(getOrBuildTrie(cache, routes), urlParts);
+	const trie = getOrBuildTrie(cache, routes);
+	return trieMatch(trie, urlParts);
 }
 //#endregion
 export { createRouteTrieCache, matchRouteWithTrie, matchRouteWithTrieRawPathname };

package/dist/routing/route-pattern.d.ts

@@ -1,19 +1,19 @@
 //#region src/routing/route-pattern.d.ts
-type RoutePatternParams = Record<string, string | string[]>;
-declare function routePatternParts(pathname: string): string[];
-declare function routePattern(pathname: string): string;
-declare function fillRoutePatternSegments(pathname: string, params: RoutePatternParams): string | null;
-declare function matchRoutePattern(urlParts: readonly string[], patternParts: readonly string[]): RoutePatternParams | null;
-declare function matchRoutePatternRaw(urlParts: readonly string[], patternParts: readonly string[]): RoutePatternParams | null;
+export type RoutePatternParams = Record<string, string | string[]>;
+export declare function routePatternParts(pathname: string): string[];
+export declare function routePattern(pathname: string): string;
+export declare function fillRoutePatternSegments(pathname: string, params: RoutePatternParams): string | null;
+export declare function matchRoutePattern(urlParts: readonly string[], patternParts: readonly string[]): RoutePatternParams | null;
+export declare function matchRoutePatternRaw(urlParts: readonly string[], patternParts: readonly string[]): RoutePatternParams | null;
 /**
  * Extract params from the original encoded URL parts after route selection has
  * already succeeded against normalized parts. Static parts are positional and
  * intentionally not compared because their raw encoding can differ from the
  * normalized route spelling (for example `%5Fsites` versus `_sites`).
  */
-declare function extractRawRoutePatternParams(patternParts: readonly string[], urlParts: readonly string[]): RoutePatternParams;
-declare function matchRoutePatternPrefix(pathParts: readonly string[], patternParts: readonly string[]): boolean;
-declare function matchRoutePatternWithOptionalDynamicSegments(pathParts: readonly string[], patternParts: readonly string[]): boolean;
+export declare function extractRawRoutePatternParams(patternParts: readonly string[], urlParts: readonly string[]): RoutePatternParams;
+export declare function matchRoutePatternPrefix(pathParts: readonly string[], patternParts: readonly string[]): boolean;
+export declare function matchRoutePatternWithOptionalDynamicSegments(pathParts: readonly string[], patternParts: readonly string[]): boolean;
 /**
  * A single entry from `getStaticPaths().paths`.
  *
@@ -27,7 +27,7 @@ declare function matchRoutePatternWithOptionalDynamicSegments(pathParts: readonl
  *     `typeof entry === 'string'` branch around line 89, and the object
  *     branch around line 132)
  */
-type StaticPathsEntry = string | {
+export type StaticPathsEntry = string | {
   params?: RoutePatternParams;
   locale?: string;
 } | null | undefined;
@@ -48,7 +48,7 @@ type NormalizedStaticPathsEntry = {
  * both the build-time prerender and the request-time matchers normalize the
  * same way.
  */
-declare function normalizeStaticPathname(pathname: string): string;
+export declare function normalizeStaticPathname(pathname: string): string;
 /**
  * Normalize a single `getStaticPaths` entry into a `{ params }` object.
  *
@@ -67,6 +67,5 @@ declare function normalizeStaticPathname(pathname: string): string;
  * string entries are not produced. If/when i18n is wired through prerender,
  * locale handling should be added here, not duplicated at call sites.
  */
-declare function normalizeStaticPathsEntry(entry: StaticPathsEntry, routePattern: string): NormalizedStaticPathsEntry;
-//#endregion
-export { RoutePatternParams, StaticPathsEntry, extractRawRoutePatternParams, fillRoutePatternSegments, matchRoutePattern, matchRoutePatternPrefix, matchRoutePatternRaw, matchRoutePatternWithOptionalDynamicSegments, normalizeStaticPathname, normalizeStaticPathsEntry, routePattern, routePatternParts };
+export declare function normalizeStaticPathsEntry(entry: StaticPathsEntry, routePattern: string): NormalizedStaticPathsEntry;
+//#endregion

package/dist/routing/route-trie.d.ts

@@ -12,7 +12,7 @@
  * Backtracking via recursive DFS ensures that dead-end static/dynamic
  * branches fall through to catch-all alternatives.
  */
-type TrieNode<R> = {
+export type TrieNode<R> = {
   staticChildren: Map<string, TrieNode<R>>;
   dynamicChild: {
     paramName: string;
@@ -41,7 +41,7 @@ type TrieNode<R> = {
  * First route to claim a terminal position wins (routes are pre-sorted
  * by precedence, so insertion order preserves correct priority).
  */
-declare function buildRouteTrie<R extends {
+export declare function buildRouteTrie<R extends {
   patternParts: string[];
 }>(routes: R[]): TrieNode<R>;
 /**
@@ -59,13 +59,12 @@ declare function buildRouteTrie<R extends {
  * @param urlParts - Pre-split URL segments (no empty strings)
  * @returns Match result with route and extracted params, or null
  */
-declare function trieMatch<R>(root: TrieNode<R>, urlParts: string[]): {
+export declare function trieMatch<R>(root: TrieNode<R>, urlParts: string[]): {
   route: R;
   params: Record<string, string | string[]>;
 } | null;
-declare function trieMatchRaw<R>(root: TrieNode<R>, urlParts: string[]): {
+export declare function trieMatchRaw<R>(root: TrieNode<R>, urlParts: string[]): {
   route: R;
   params: Record<string, string | string[]>;
 } | null;
-//#endregion
-export { TrieNode, buildRouteTrie, trieMatch, trieMatchRaw };
+//#endregion

package/dist/routing/route-validation.d.ts

@@ -4,7 +4,6 @@
  * Source:
  * https://github.com/vercel/next.js/blob/canary/packages/next/src/shared/lib/router/utils/sorted-routes.ts
  */
-declare function patternToNextFormat(pattern: string): string;
-declare function validateRoutePatterns(patterns: readonly string[]): void;
-//#endregion
-export { patternToNextFormat, validateRoutePatterns };
+export declare function patternToNextFormat(pattern: string): string;
+export declare function validateRoutePatterns(patterns: readonly string[]): void;
+//#endregion

package/dist/routing/route-validation.js

@@ -43,18 +43,19 @@ var UrlNode = class UrlNode {
 				}
 				slugNames.push(nextSlug);
 			};
-			if (isCatchAll) if (isOptional) {
-				if (this.restSlugName !== null) throw new Error(`You cannot use both an required and optional catch-all route at the same level ("[...${this.restSlugName}]" and "${urlPaths[0]}" ).`);
-				handleSlug(this.optionalRestSlugName, segmentName);
-				this.optionalRestSlugName = segmentName;
-				nextSegment = "[[...]]";
+			if (isCatchAll) {
+				if (isOptional) {
+					if (this.restSlugName !== null) throw new Error(`You cannot use both an required and optional catch-all route at the same level ("[...${this.restSlugName}]" and "${urlPaths[0]}" ).`);
+					handleSlug(this.optionalRestSlugName, segmentName);
+					this.optionalRestSlugName = segmentName;
+					nextSegment = "[[...]]";
+				} else {
+					if (this.optionalRestSlugName !== null) throw new Error(`You cannot use both an optional and required catch-all route at the same level ("[[...${this.optionalRestSlugName}]]" and "${urlPaths[0]}").`);
+					handleSlug(this.restSlugName, segmentName);
+					this.restSlugName = segmentName;
+					nextSegment = "[...]";
+				}
 			} else {
-				if (this.optionalRestSlugName !== null) throw new Error(`You cannot use both an optional and required catch-all route at the same level ("[[...${this.optionalRestSlugName}]]" and "${urlPaths[0]}").`);
-				handleSlug(this.restSlugName, segmentName);
-				this.restSlugName = segmentName;
-				nextSegment = "[...]";
-			}
-			else {
 				if (isOptional) throw new Error(`Optional route parameters are not yet supported ("${urlPaths[0]}").`);
 				handleSlug(this.slugName, segmentName);
 				this.slugName = segmentName;

package/dist/routing/utils.d.ts

@@ -12,7 +12,7 @@
  *
  * Usage: sortRoutes(routes)
  */
-declare function sortRoutes<T extends {
+export declare function sortRoutes<T extends {
   pattern: string;
 }>(routes: T[]): T[];
 /**
@@ -36,23 +36,23 @@ declare function sortRoutes<T extends {
  *   compareHybridRoutePatterns("/:path+", true, "/dashboard", false)  // → "app"
  *   compareHybridRoutePatterns("/", false, "/", false)  // → "app"
  */
-declare function compareHybridRoutePatterns(pagesPattern: string, pagesIsDynamic: boolean, appPattern: string, appIsDynamic: boolean): "app" | "pages";
+export declare function compareHybridRoutePatterns(pagesPattern: string, pagesIsDynamic: boolean, appPattern: string, appIsDynamic: boolean): "app" | "pages";
 /**
  * Decode a filesystem or URL path segment while preserving encoded path delimiters.
  * Mirrors Next.js segment-wise decoding so "%5F" becomes "_" but "%2F" stays "%2F".
  */
-declare function decodeRouteSegment(segment: string): string;
+export declare function decodeRouteSegment(segment: string): string;
 /**
  * Normalize a pathname for route matching by decoding each segment independently.
  * This prevents encoded slashes from turning into real path separators.
  */
-declare function normalizePathnameForRouteMatch(pathname: string): string;
-declare function splitPathnameForRouteMatch(pathname: string): string[];
+export declare function normalizePathnameForRouteMatch(pathname: string): string;
+export declare function splitPathnameForRouteMatch(pathname: string): string[];
 /**
  * Strict pathname normalization for live request handling.
  * Throws on malformed percent-encoding so callers can return 400.
  */
-declare function normalizePathnameForRouteMatchStrict(pathname: string): string;
+export declare function normalizePathnameForRouteMatchStrict(pathname: string): string;
 /**
  * Build a params object from ordered entries, preserving insertion order.
  *
@@ -62,34 +62,33 @@ declare function normalizePathnameForRouteMatchStrict(pathname: string): string;
  *
  * @param entries - Ordered [paramName, value] tuples from forward traversal
  */
-declare function buildParams(entries: Array<[string, string | string[]]>): Record<string, string | string[]>;
+export declare function buildParams(entries: Array<[string, string | string[]]>): Record<string, string | string[]>;
 /**
  * Decode captured route params with `decodeURIComponent`, mirroring Next.js
  * route-matcher.ts:25-27. Mutates the params object in place. Catch-all
  * arrays are decoded element-wise. Malformed escapes are preserved (the
  * strict normalization layer rejects them at the request boundary).
  */
-declare function decodeMatchedParams(params: Record<string, string | string[]>): void;
+export declare function decodeMatchedParams(params: Record<string, string | string[]>): void;
 /**
  * Check whether a path segment is invisible in the URL (route groups, parallel
  * slots, "."). Single source of truth shared by the route graph (Node) and
  * browser-side bfcache identity logic. Lives in this browser-safe utils module
  * so importing it does not drag node:path/node:fs into the client bundle.
  */
-declare function isInvisibleSegment(segment: string): boolean;
+export declare function isInvisibleSegment(segment: string): boolean;
 /** Split a pathname into its non-empty segments without decoding. */
-declare function splitPathSegments(pathname: string): string[];
+export declare function splitPathSegments(pathname: string): string[];
 /**
  * Catch-all filesystem segment, e.g. `[...slug]`. Browser-safe predicate shared
  * with the route graph's segment parsing (dynamicParamNameFromSegment) so the
  * bracket conventions live in one place. The length guard rejects empty names
  * (`[...]`).
  */
-declare function isCatchAllSegment(segment: string): boolean;
+export declare function isCatchAllSegment(segment: string): boolean;
 /**
  * Optional-catch-all filesystem segment, e.g. `[[...slug]]`. Unlike a catch-all,
  * this matches zero or more URL segments.
  */
-declare function isOptionalCatchAllSegment(segment: string): boolean;
-//#endregion
-export { buildParams, compareHybridRoutePatterns, decodeMatchedParams, decodeRouteSegment, isCatchAllSegment, isInvisibleSegment, isOptionalCatchAllSegment, normalizePathnameForRouteMatch, normalizePathnameForRouteMatchStrict, sortRoutes, splitPathSegments, splitPathnameForRouteMatch };
+export declare function isOptionalCatchAllSegment(segment: string): boolean;
+//#endregion

package/dist/server/accept-encoding.d.ts

@@ -1,27 +1,26 @@
 import { IncomingMessage } from "node:http";
 //#region src/server/accept-encoding.d.ts
 type ContentEncoding = "zstd" | "br" | "gzip" | "deflate";
-type NegotiatedEncoding = ContentEncoding | "identity";
+export type NegotiatedEncoding = ContentEncoding | "identity";
 /** Parsed explicit coding qualities plus the wildcard quality, when present. */
-type ParsedAcceptEncoding = {
+export type ParsedAcceptEncoding = {
   qualities: Map<string, number>;
   orders: Map<string, number>;
   wildcardQuality: number | null;
 };
 /** Parse an Accept-Encoding header into exact-token numeric qualities. */
-declare function parseAcceptedEncodings(accept: string): ParsedAcceptEncoding;
+export declare function parseAcceptedEncodings(accept: string): ParsedAcceptEncoding;
 /** Return the effective quality for a coding, including wildcard/identity rules. */
-declare function getEncodingQuality(parsed: ParsedAcceptEncoding, encoding: string): number;
+export declare function getEncodingQuality(parsed: ParsedAcceptEncoding, encoding: string): number;
 /** Choose the highest-quality available coding, using array order as the tie-breaker. */
-declare function selectAcceptedEncoding<T extends string>(parsed: ParsedAcceptEncoding, available: readonly T[]): T | null;
+export declare function selectAcceptedEncoding<T extends string>(parsed: ParsedAcceptEncoding, available: readonly T[]): T | null;
 /**
  * Select a content coding while matching Next.js's compression middleware:
  * an explicit identity preference can win, but implicit identity remains a
  * fallback rather than suppressing an otherwise acceptable encoding.
  */
-declare function selectContentEncoding<T extends ContentEncoding>(parsed: ParsedAcceptEncoding, available: readonly T[]): T | "identity";
-declare const HAS_ZSTD: boolean;
+export declare function selectContentEncoding<T extends ContentEncoding>(parsed: ParsedAcceptEncoding, available: readonly T[]): T | "identity";
+export declare const HAS_ZSTD: boolean;
 /** Select by client q-value first, then zstd > br > gzip > deflate > identity. */
-declare function negotiateEncoding(req: IncomingMessage): NegotiatedEncoding;
-//#endregion
-export { HAS_ZSTD, NegotiatedEncoding, ParsedAcceptEncoding, getEncodingQuality, negotiateEncoding, parseAcceptedEncodings, selectAcceptedEncoding, selectContentEncoding };
+export declare function negotiateEncoding(req: IncomingMessage): NegotiatedEncoding;
+//#endregion

package/dist/server/api-handler.d.ts

@@ -7,12 +7,11 @@ import { IncomingMessage, ServerResponse } from "node:http";
  * Handle an API route request.
  * Returns true if the request was handled, false if no API route matched.
  */
-declare function handleApiRoute(runner: ModuleImporter, req: IncomingMessage, res: ServerResponse, url: string, apiRoutes: Route[], nextConfig?: {
+export declare function handleApiRoute(runner: ModuleImporter, req: IncomingMessage, res: ServerResponse, url: string, apiRoutes: Route[], nextConfig?: {
   basePath?: string;
   i18n?: NextI18nConfig | null;
   trustedRevalidateOrigin?: string;
   allowedRevalidateHeaderKeys?: readonly string[];
   trailingSlash?: boolean;
 }): Promise<boolean>;
-//#endregion
-export { handleApiRoute };
+//#endregion

package/dist/server/api-handler.js

@@ -4,6 +4,7 @@ import "./server-globals.js";
 import { NextRequest } from "../shims/server.js";
 import { importModule, reportRequestError } from "./instrumentation.js";
 import { mergeRouteParamsIntoQuery, parseQueryString, urlQueryToSearchParams } from "../utils/query.js";
+import { tracePagesApiHandler } from "./pages-execution-tracing.js";
 import { DEFAULT_PAGES_API_BODY_SIZE_LIMIT, resolveBodyParserConfig } from "./pages-body-parser-config.js";
 import { PagesBodyParseError, getMediaType, isJsonMediaType } from "./pages-media-type.js";
 import { resolveRequestHost, resolveRequestProtocol } from "./proxy-trust.js";
@@ -100,7 +101,8 @@ function createEdgeApiRequest(req, url, params, nextConfig) {
 	const requestUrl = new URL(req.url ?? url, `${proto}://${host}`);
 	const basePath = nextConfig?.basePath;
 	if (basePath && !hasBasePath(requestUrl.pathname, basePath)) requestUrl.pathname = `${basePath}${requestUrl.pathname}`;
-	requestUrl.search = urlQueryToSearchParams(mergeRouteParamsIntoQuery(parseQueryString(url), params)).toString();
+	const query = mergeRouteParamsIntoQuery(parseQueryString(url), params);
+	requestUrl.search = urlQueryToSearchParams(query).toString();
 	const body = readEdgeRequestBody(req);
 	const init = {
 		headers,
@@ -227,7 +229,7 @@ async function handleApiRoute(runner, req, res, url, apiRoutes, nextConfig) {
 				i18n: nextConfig.i18n ?? void 0,
 				trailingSlash: nextConfig.trailingSlash
 			} } : void 0);
-			const handlerResponse = await apiModule.default(nextRequest);
+			const handlerResponse = await tracePagesApiHandler(route.pattern, () => apiModule.default(nextRequest));
 			if (!(handlerResponse instanceof Response)) throw new Error("Edge API route did not return a Response");
 			const response = finalizeEdgeApiResponse(handlerResponse, "node");
 			res.statusCode = response.status;
@@ -250,7 +252,7 @@ async function handleApiRoute(runner, req, res, url, apiRoutes, nextConfig) {
 		const query = mergeRouteParamsIntoQuery(parseQueryString(url), params);
 		const bodyParserConfig = resolveBodyParserConfig(apiModule.config);
 		const { apiReq, apiRes } = enhanceApiObjects(req, res, query, bodyParserConfig.enabled ? await parseBody(req, bodyParserConfig.sizeLimit) : void 0, nextConfig?.trustedRevalidateOrigin, nextConfig?.allowedRevalidateHeaderKeys, true);
-		await handler(apiReq, apiRes);
+		await tracePagesApiHandler(route.pattern, () => handler(apiReq, apiRes));
 		return true;
 	} catch (e) {
 		if (e instanceof PagesBodyParseError) {
@@ -260,14 +262,15 @@ async function handleApiRoute(runner, req, res, url, apiRoutes, nextConfig) {
 			return true;
 		}
 		console.error(e);
-		reportRequestError(e instanceof Error ? e : new Error(String(e)), {
+		await reportRequestError(e, {
 			path: url,
 			method: req.method ?? "GET",
-			headers: Object.fromEntries(Object.entries(req.headers).filter(([k]) => !k.startsWith(":")).map(([k, v]) => [k, Array.isArray(v) ? v.join(", ") : String(v ?? "")]))
+			headers: Object.fromEntries(Object.entries(req.headers).filter(([k]) => !k.startsWith(":")))
 		}, {
 			routerKind: "Pages Router",
 			routePath: match.route.pattern,
-			routeType: "route"
+			routeType: "route",
+			revalidateReason: void 0
 		});
 		if (!res.headersSent) {
 			res.statusCode = 500;

package/dist/server/app-action-forwarding.d.ts

@@ -12,7 +12,6 @@ type ForwardServerActionOptions = {
   middlewareContext: AppMiddlewareContext;
   request: Request;
 };
-declare function areServerActionsOwnedByRoute(actionOwners: ActionOwnerManifest | null, actionIds: readonly string[], currentRoutePattern: string | null): boolean;
-declare function forwardServerActionIfNeeded(options: ForwardServerActionOptions): Promise<Response | null>;
-//#endregion
-export { areServerActionsOwnedByRoute, forwardServerActionIfNeeded };
+export declare function areServerActionsOwnedByRoute(actionOwners: ActionOwnerManifest | null, actionIds: readonly string[], currentRoutePattern: string | null): boolean;
+export declare function forwardServerActionIfNeeded(options: ForwardServerActionOptions): Promise<Response | null>;
+//#endregion

package/dist/server/app-action-forwarding.js

@@ -1,6 +1,6 @@
+import { buildRequestHeadersFromMiddlewareResponse } from "../utils/middleware-request-headers.js";
 import { patternToNextFormat } from "../routing/route-validation.js";
 import "./headers.js";
-import { buildRequestHeadersFromMiddlewareResponse } from "../utils/middleware-request-headers.js";
 import { RequestCookies, ResponseCookies } from "../shims/server.js";
 import { attachRequestCfMetadata, processMiddlewareHeaders, validateCsrfOrigin } from "./request-pipeline.js";
 import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";

package/dist/server/app-action-request.d.ts

@@ -1,4 +1,3 @@
 //#region src/server/app-action-request.d.ts
-declare function isPossibleAppRouteActionRequest(request: Pick<Request, "headers" | "method">): boolean;
-//#endregion
-export { isPossibleAppRouteActionRequest };
+export declare function isPossibleAppRouteActionRequest(request: Pick<Request, "headers" | "method">): boolean;
+//#endregion

package/dist/server/app-bfcache-id.d.ts

@@ -1,5 +1,4 @@
 //#region src/server/app-bfcache-id.d.ts
-declare const INITIAL_BFCACHE_ID = "0";
-declare const PUBLIC_INITIAL_BFCACHE_ID = "_b_0_";
-//#endregion
-export { INITIAL_BFCACHE_ID, PUBLIC_INITIAL_BFCACHE_ID };
+export declare const INITIAL_BFCACHE_ID = "0";
+export declare const PUBLIC_INITIAL_BFCACHE_ID = "_b_0_";
+//#endregion

package/dist/server/app-bfcache-identity.d.ts

@@ -3,33 +3,32 @@ import { AppElements, AppElementsWire } from "./app-elements-wire.js";
 import "./app-elements.js";
 import { BfcacheIdMap } from "./app-history-state.js";
 //#region src/server/app-bfcache-identity.d.ts
-type BfcacheSegmentIdentityMap = Readonly<Record<string, BfcacheSegmentIdentity>>;
-type InitialBfcacheMaps = Readonly<{
+export type BfcacheSegmentIdentityMap = Readonly<Record<string, BfcacheSegmentIdentity>>;
+export type InitialBfcacheMaps = Readonly<{
   bfcacheIds: BfcacheIdMap;
   identities: BfcacheSegmentIdentityMap;
 }>;
 type AppElementsMetadata = ReturnType<typeof AppElementsWire.readMetadata>;
-declare function createInitialBfcacheIdMap(elements: AppElements): BfcacheIdMap;
-declare function createBfcacheSegmentIdentityMap(options: {
+export declare function createInitialBfcacheIdMap(elements: AppElements): BfcacheIdMap;
+export declare function createBfcacheSegmentIdentityMap(options: {
   elements: AppElements;
 }): BfcacheSegmentIdentityMap;
-declare function createInitialBfcacheMaps(options: {
+export declare function createInitialBfcacheMaps(options: {
   elements: AppElements;
   metadata: AppElementsMetadata;
 }): InitialBfcacheMaps;
-declare function createNextBfcacheIdMap(options: {
+export declare function createNextBfcacheIdMap(options: {
   current: BfcacheIdMap;
   currentElements: AppElements;
   elements: AppElements;
   restored?: BfcacheIdMap | null;
   reuseCurrent?: boolean;
 }): BfcacheIdMap;
-declare function preserveBfcacheIdsForMergedElements(options: {
+export declare function preserveBfcacheIdsForMergedElements(options: {
   elements: AppElements;
   next: BfcacheIdMap;
   previous: BfcacheIdMap;
   preservedElementIds?: readonly string[];
   preservePreviousIds?: readonly string[];
 }): BfcacheIdMap;
-//#endregion
-export { BfcacheSegmentIdentityMap, InitialBfcacheMaps, createBfcacheSegmentIdentityMap, createInitialBfcacheIdMap, createInitialBfcacheMaps, createNextBfcacheIdMap, preserveBfcacheIdsForMergedElements };
+//#endregion