vinext 1.0.0-beta.9 → 1.0.1

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,5 @@
 //#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_";
+export declare function isBfcacheSegmentId(id: string): boolean;
+//#endregion

package/dist/server/app-bfcache-id.js

@@ -1,5 +1,11 @@
+import { AppElementsWire } from "./app-elements-wire.js";
+import "./app-elements.js";
 //#region src/server/app-bfcache-id.ts
 const INITIAL_BFCACHE_ID = "0";
 const PUBLIC_INITIAL_BFCACHE_ID = "_b_0_";
+function isBfcacheSegmentId(id) {
+	const parsed = AppElementsWire.parseElementKey(id);
+	return parsed?.kind === "layout" || parsed?.kind === "page" || parsed?.kind === "slot" || parsed?.kind === "template";
+}
 //#endregion
-export { INITIAL_BFCACHE_ID, PUBLIC_INITIAL_BFCACHE_ID };
+export { INITIAL_BFCACHE_ID, PUBLIC_INITIAL_BFCACHE_ID, isBfcacheSegmentId };

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

package/dist/server/app-bfcache-identity.js

@@ -1,8 +1,7 @@
 import { AppElementsWire } from "./app-elements-wire.js";
 import "./app-elements.js";
 import { isNestedBfcacheSlotSegmentIdFor } from "./bfcache-identity.js";
-import "./app-bfcache-id.js";
-import { isBfcacheSegmentId } from "./app-history-state.js";
+import { isBfcacheSegmentId } from "./app-bfcache-id.js";
 //#region src/server/app-bfcache-identity.ts
 let nextBfcacheId = 0;
 function rememberBfcacheId(value) {

package/dist/server/app-browser-action-result.d.ts

@@ -1,14 +1,14 @@
 import { OperationLane } from "./operation-token.js";
 import { ServerActionResultFacts } from "./navigation-planner.js";
 //#region src/server/app-browser-action-result.d.ts
-type AppBrowserServerActionResult<TRoot> = {
+export type AppBrowserServerActionResult<TRoot> = {
   root?: TRoot;
   returnValue?: {
     ok: boolean;
     data: unknown;
   };
 };
-type ServerActionRevalidationKind = "dynamicOnly" | "none" | "staticAndDynamic";
+export type ServerActionRevalidationKind = "dynamicOnly" | "none" | "staticAndDynamic";
 type ServerActionInitiationSnapshot<TRouterState> = {
   href: string;
   navigationId: number;
@@ -21,14 +21,14 @@ type ServerActionInitiationSnapshot<TRouterState> = {
  * `slot:`, `__route`, etc.) and will never collide with these property names.
  * If the wire format ever adds a `"root"` key, this guard must be updated.
  */
-declare function isServerActionResult<TRoot>(value: unknown): value is AppBrowserServerActionResult<TRoot>;
-declare function shouldClearClientNavigationCachesForServerActionResult<TRoot>(result: AppBrowserServerActionResult<TRoot> | TRoot, revalidation?: ServerActionRevalidationKind): boolean;
-declare function parseServerActionRevalidationHeader(headers: Pick<Headers, "get">): ServerActionRevalidationKind;
-declare function resolveServerActionOperationLane(revalidation: ServerActionRevalidationKind): Extract<OperationLane, "refresh" | "server-action">;
-declare function normalizeServerActionThrownValue(data: unknown, responseStatus: number): unknown;
-declare function shouldSyncServerActionHttpFallbackHead<TRoot>(result: AppBrowserServerActionResult<TRoot> | TRoot): boolean;
-declare function readInvalidServerActionResponseError(response: Pick<Response, "headers" | "status" | "text">, hasRedirectLocation: boolean): Promise<Error | null>;
-type ServerActionResultResponseFactsInput = {
+export declare function isServerActionResult<TRoot>(value: unknown): value is AppBrowserServerActionResult<TRoot>;
+export declare function shouldClearClientNavigationCachesForServerActionResult<TRoot>(result: AppBrowserServerActionResult<TRoot> | TRoot, revalidation?: ServerActionRevalidationKind): boolean;
+export declare function parseServerActionRevalidationHeader(headers: Pick<Headers, "get">): ServerActionRevalidationKind;
+export declare function resolveServerActionOperationLane(revalidation: ServerActionRevalidationKind): Extract<OperationLane, "refresh" | "server-action">;
+export declare function normalizeServerActionThrownValue(data: unknown, responseStatus: number): unknown;
+export declare function shouldSyncServerActionHttpFallbackHead<TRoot>(result: AppBrowserServerActionResult<TRoot> | TRoot): boolean;
+export declare function readInvalidServerActionResponseError(response: Pick<Response, "headers" | "status" | "text">, hasRedirectLocation: boolean): Promise<Error | null>;
+export type ServerActionResultResponseFactsInput = {
   actionRedirectHref: string | null;
   actionRedirectType: string | null;
   clientCompatibilityId: string | null;
@@ -44,9 +44,9 @@ type ServerActionResultResponseFactsInput = {
  * normalisation and RSC content-type detection happen for server-action
  * compatibility checks.
  */
-declare function createServerActionResultFacts(input: ServerActionResultResponseFactsInput): ServerActionResultFacts;
-declare function shouldScheduleRefreshForDiscardedServerAction(revalidation: ServerActionRevalidationKind): boolean;
-declare function createServerActionInitiationSnapshot<TRouterState>(options: {
+export declare function createServerActionResultFacts(input: ServerActionResultResponseFactsInput): ServerActionResultFacts;
+export declare function shouldScheduleRefreshForDiscardedServerAction(revalidation: ServerActionRevalidationKind): boolean;
+export declare function createServerActionInitiationSnapshot<TRouterState>(options: {
   href: string;
   navigationId: number;
   origin?: string;
@@ -61,6 +61,5 @@ type DiscardedServerActionRefreshSchedulerOptions = {
   queueTask?: (callback: () => void) => void;
   runRefresh: () => void;
 };
-declare function createDiscardedServerActionRefreshScheduler(options: DiscardedServerActionRefreshSchedulerOptions): DiscardedServerActionRefreshScheduler;
-//#endregion
-export { AppBrowserServerActionResult, ServerActionResultResponseFactsInput, ServerActionRevalidationKind, createDiscardedServerActionRefreshScheduler, createServerActionInitiationSnapshot, createServerActionResultFacts, isServerActionResult, normalizeServerActionThrownValue, parseServerActionRevalidationHeader, readInvalidServerActionResponseError, resolveServerActionOperationLane, shouldClearClientNavigationCachesForServerActionResult, shouldScheduleRefreshForDiscardedServerAction, shouldSyncServerActionHttpFallbackHead };
+export declare function createDiscardedServerActionRefreshScheduler(options: DiscardedServerActionRefreshSchedulerOptions): DiscardedServerActionRefreshScheduler;
+//#endregion

package/dist/server/app-browser-client-reuse-manifest.d.ts

@@ -6,6 +6,5 @@ type VisibleAppState = Pick<AppRouterState, "elements" | "visibleCommitVersion">
 type CreateClientReuseManifestHeaderOptions = Readonly<{
   limits?: ClientReuseManifestLimits;
 }>;
-declare function createClientReuseManifestHeaderFromVisibleAppState(state: VisibleAppState, options?: CreateClientReuseManifestHeaderOptions): string | null;
-//#endregion
-export { createClientReuseManifestHeaderFromVisibleAppState };
+export declare function createClientReuseManifestHeaderFromVisibleAppState(state: VisibleAppState, options?: CreateClientReuseManifestHeaderOptions): string | null;
+//#endregion