vinext 1.0.0-beta.8 → 1.0.0

package/dist/server/app-segment-config.d.ts

@@ -21,10 +21,24 @@ type EffectiveAppPageSegmentConfig = {
 type ParallelAppPageSegmentConfigBranch = {
   configLayouts?: readonly (AppRouteSegmentConfigModule | null | undefined)[] | null;
   configLayoutTreePositions?: readonly number[] | null;
+  /** Whether the slot renders its `default` module instead of a matched page. */
+  isDefault?: boolean;
   layout?: AppRouteSegmentConfigModule | null;
+  /** The slot's name, which orders sibling slots in the loader tree. */
+  name?: string;
+  /** The main-tree position of the folder that owns the slot. */
+  ownerTreePosition?: number | null;
   page?: AppRouteSegmentConfigModule | null;
   routeSegments?: readonly string[] | null;
 };
+/**
+ * The route's implicit `children` slot. A route that only a nested slot page
+ * materializes renders the owner's `default` (or nothing) as its children.
+ */
+type AppPageChildrenSlot = {
+  ownerTreePath: string;
+  state: "active" | "default" | "unmatched";
+};
 type ResolveAppPageSegmentConfigOptions = {
   layouts?: readonly (AppRouteSegmentConfigModule | null | undefined)[];
   layoutTreePositions?: readonly number[];
@@ -34,6 +48,8 @@ type ResolveAppPageSegmentConfigOptions = {
   parallelSegments?: readonly (AppRouteSegmentConfigModule | null | undefined)[];
   routeSegments?: readonly string[];
 };
+/** Resolve the effective `dynamic` mode using the same traversal semantics as rendering. */
+export declare function resolveAppPageDynamicConfig(options: Pick<ResolveAppPageSegmentConfigOptions, "layouts" | "page" | "parallelBranches" | "parallelSegments">): AppRouteSegmentDynamic | undefined;
 /**
  * Resolve the route segment config that applies to an App page route.
  *
@@ -42,8 +58,8 @@ type ResolveAppPageSegmentConfigOptions = {
  * the concrete layout/page modules for a route, so it should only describe
  * those modules and delegate the behavior to this helper.
  */
-declare function resolveAppPageSegmentConfig(options: ResolveAppPageSegmentConfigOptions): EffectiveAppPageSegmentConfig;
-declare function resolveAppPageFetchCacheMode(options: ResolveAppPageSegmentConfigOptions): FetchCacheMode | null;
+export declare function resolveAppPageSegmentConfig(options: ResolveAppPageSegmentConfigOptions): EffectiveAppPageSegmentConfig;
+export declare function resolveAppPageFetchCacheMode(options: ResolveAppPageSegmentConfigOptions): FetchCacheMode | null;
 /**
  * Resolve the `fetchCache` segment config exported by a route handler module.
  *
@@ -51,7 +67,105 @@ declare function resolveAppPageFetchCacheMode(options: ResolveAppPageSegmentConf
  * directly. Mirrors upstream's app-route module, which copies
  * `userland.fetchCache` into the work store before invoking the handler.
  */
-declare function resolveAppRouteHandlerFetchCacheMode(handler: Pick<AppRouteSegmentConfigModule, "fetchCache">): FetchCacheMode | null;
-declare function isEdgeRuntime(runtime: string | undefined): boolean;
-//#endregion
-export { isEdgeRuntime, resolveAppPageFetchCacheMode, resolveAppPageSegmentConfig, resolveAppRouteHandlerFetchCacheMode };
+export declare function resolveAppRouteHandlerFetchCacheMode(handler: Pick<AppRouteSegmentConfigModule, "fetchCache">): FetchCacheMode | null;
+export declare function isEdgeRuntime(runtime: string | undefined): boolean;
+/**
+ * Resolve a `runtime` from a chain of segment values, outermost first: the
+ * last valid value wins, as a child's value wins over its parent's.
+ * `collectAppPageStaticGenerationRuntimes` supplies the value Next.js uses to
+ * decide whether a page can be statically generated.
+ */
+export declare function resolveAppPageStaticGenerationRuntime(values: readonly unknown[]): EffectiveAppPageSegmentConfig["runtime"];
+/**
+ * The `runtime` Next.js's default build (Turbopack) derives for an App page,
+ * for `resolveAppPageStaticGenerationRuntime`. It reads the whole loader tree:
+ * at each node the values of every parallel branch (children, matched slots
+ * and slots that render `default`) merge, and a conflict fails the build; the
+ * node's own layout, page or default module then fills in only an unset value.
+ * So an edge slot page next to a Node children page makes the route edge.
+ * https://github.com/vercel/next.js/blob/v16.2.7/crates/next-core/src/segment_config.rs#L1323-L1357
+ * https://github.com/vercel/next.js/blob/v16.2.7/crates/next-core/src/next_app/app_page_entry.rs#L40-L41
+ */
+export declare function collectAppPageStaticGenerationRuntimes(options: Parameters<typeof collectAppPageStaticParamsWalkSegments>[0]): unknown[];
+/**
+ * One segment of an App page's loader tree, as Next.js's build visits it when
+ * it classifies the route.
+ */
+export type AppPageStaticParamsWalkSegment = {
+  /** Whether the segment is a dynamic URL segment (`[slug]`, `[...slug]`). */
+  dynamic: boolean;
+  /** Whether the segment's layout (or page) exports `generateStaticParams`. */
+  generateStaticParams: boolean;
+  /**
+   * The segment name and the file that supplies its module. Next.js visits
+   * each distinct pair once, so a slot's layout-less `[slug]` folder that
+   * repeats the main tree's does not count twice.
+   */
+  identity: readonly [name: string, file: unknown];
+  /**
+   * The segment's position in the loader tree: its index among its parent's
+   * children at each level, from the root. The root layout's segment is `[]`.
+   */
+  treePath: readonly number[];
+};
+/**
+ * Whether `generateStaticParams` is exported at or below the route's last
+ * dynamic segment: by that segment's layout, a deeper layout, or the page.
+ * Next.js classifies such a route as SSG (static generation with an on-demand
+ * fallback). A dynamic-segment route without it is dynamic (ƒ) and is never
+ * full-page cached.
+ *
+ * Port of Next.js's `lastDynamicSegmentHadGenerateStaticParams` walk: segments
+ * are visited breadth-first, a dynamic segment without `generateStaticParams`
+ * clears the flag, and any segment with it sets the flag.
+ * https://github.com/vercel/next.js/blob/v16.2.6/packages/next/src/build/static-paths/app.ts#L926-L935
+ * https://github.com/vercel/next.js/blob/v16.2.6/packages/next/src/build/segment-config/app/app-segments.ts#L72-L126
+ */
+export declare function lastDynamicSegmentHasGenerateStaticParams(segments: readonly AppPageStaticParamsWalkSegment[]): boolean;
+/**
+ * Collect the loader-tree segments of an App page route from its layout, page
+ * and parallel-slot modules, for `lastDynamicSegmentHasGenerateStaticParams`.
+ *
+ * Children follow the loader tree Next.js's default build (Turbopack) makes:
+ * `children` first, then every slot in folder-name order, whether it matched
+ * a page or renders `default`. A default slot is a single `__DEFAULT__`
+ * segment without the slot's layout.
+ * https://github.com/vercel/next.js/blob/v16.2.7/crates/next-core/src/app_structure.rs#L1489-L1511
+ * https://github.com/vercel/next.js/blob/v16.2.7/crates/next-core/src/app_structure.rs#L1515-L1548
+ */
+export declare function collectAppPageStaticParamsWalkSegments(options: Pick<ResolveAppPageSegmentConfigOptions, "layoutTreePositions" | "layouts" | "page" | "parallelBranches" | "routeSegments"> & {
+  childrenSlot?: AppPageChildrenSlot | null;
+}): AppPageStaticParamsWalkSegment[];
+/**
+ * Whether an App page route exports `generateStaticParams` at or below its last
+ * dynamic segment, read from its layout, page and parallel-slot modules.
+ */
+export declare function hasAppPageGenerateStaticParamsAtLastDynamicSegment(options: Parameters<typeof collectAppPageStaticParamsWalkSegments>[0]): boolean;
+/**
+ * Whether Next.js would classify an App page route as static or SSG from its
+ * config alone. Only such routes are full-page cache candidates; every other
+ * route renders per request with real values and is never ISR-cached.
+ *
+ * - `runtime = "edge"` disables static generation, whatever else the route
+ *   sets.
+ * - `dynamic = "force-dynamic"` and `revalidate = 0` are dynamic.
+ * - `dynamic = "force-static"` and `dynamic = "error"` are static.
+ * - Otherwise a route is static when it has no dynamic segments, or when
+ *   `generateStaticParams` sits at or below its last dynamic segment.
+ *
+ * Next.js also treats a route as SSG when an ancestor's `generateStaticParams`
+ * returns every pathname param (`hadAllParamsGenerated`). That depends on the
+ * generator's output, which vinext doesn't compute per request, so such a
+ * route is treated as dynamic here. Adding `generateStaticParams` to the last
+ * dynamic segment (even returning `[]`) opts it in, on both.
+ *
+ * https://github.com/vercel/next.js/blob/v16.2.6/packages/next/src/build/index.ts#L2333-L2408
+ */
+export declare function isAppPageStaticEligible(options: {
+  dynamicConfig?: string;
+  hasGenerateStaticParams: boolean;
+  isDynamicRoute: boolean;
+  isStaticGenerationEdgeRuntime: boolean;
+  revalidateSeconds: number | null;
+}): boolean;
+//#endregion

package/dist/server/app-segment-config.js

@@ -57,6 +57,23 @@ function getParallelSegments(options) {
 		branch.page
 	] : []);
 }
+/** Resolve the effective `dynamic` mode using the same traversal semantics as rendering. */
+function resolveAppPageDynamicConfig(options) {
+	const segments = [...options.layouts ?? [], options.page];
+	const parallelSegments = getParallelSegments(options);
+	let dynamicConfig;
+	let hasForceDynamic = false;
+	for (const segment of segments) {
+		if (!isRouteSegmentDynamic(segment?.dynamic)) continue;
+		if (segment.dynamic === "force-dynamic") hasForceDynamic = true;
+		dynamicConfig = hasForceDynamic ? "force-dynamic" : segment.dynamic;
+	}
+	for (const segment of parallelSegments) if (segment?.dynamic === "force-dynamic") {
+		hasForceDynamic = true;
+		dynamicConfig = "force-dynamic";
+	} else if (dynamicConfig === void 0 && isRouteSegmentDynamic(segment?.dynamic)) dynamicConfig = segment.dynamic;
+	return dynamicConfig;
+}
 function resolveDynamicParamsConfig(options) {
 	const parallelSegments = getParallelSegments(options);
 	const segments = [
@@ -123,21 +140,21 @@ function describeFetchCacheConflict(value) {
 function resolveAppPageSegmentConfig(options) {
 	const segments = [...options.layouts ?? [], options.page];
 	const parallelSegments = getParallelSegments(options);
-	const config = { revalidateSeconds: null };
+	const dynamicConfig = resolveAppPageDynamicConfig(options);
+	const config = {
+		...dynamicConfig === void 0 ? {} : { dynamicConfig },
+		revalidateSeconds: null
+	};
 	config.dynamicParamsConfig = resolveDynamicParamsConfig(options);
 	let hasForceCache = false;
 	let hasForceNoStore = false;
 	let hasOnlyCache = false;
 	let hasOnlyNoStore = false;
 	let hasParentDefaultNoStore = false;
-	let hasForceDynamic = false;
+	const primaryRuntime = resolveAppPageStaticGenerationRuntime(segments.map((segment) => segment?.runtime));
+	if (primaryRuntime !== void 0) config.runtime = primaryRuntime;
 	for (const segment of segments) {
 		if (!segment) continue;
-		if (isRouteSegmentDynamic(segment.dynamic)) {
-			if (segment.dynamic === "force-dynamic") hasForceDynamic = true;
-			config.dynamicConfig = hasForceDynamic ? "force-dynamic" : segment.dynamic;
-		}
-		if (isRouteSegmentRuntime(segment.runtime)) config.runtime = segment.runtime;
 		if (isRouteSegmentFetchCache(segment.fetchCache)) {
 			const fetchCache = segment.fetchCache;
 			if (hasParentDefaultNoStore && (fetchCache === "auto" || isCacheFetchCacheMode(fetchCache))) throw new Error(describeFetchCacheConflict(fetchCache));
@@ -157,10 +174,6 @@ function resolveAppPageSegmentConfig(options) {
 	}
 	for (const segment of parallelSegments) {
 		if (!segment) continue;
-		if (segment.dynamic === "force-dynamic") {
-			hasForceDynamic = true;
-			config.dynamicConfig = "force-dynamic";
-		} else if (config.dynamicConfig === void 0 && isRouteSegmentDynamic(segment.dynamic)) config.dynamicConfig = segment.dynamic;
 		if (config.runtime === void 0 && isRouteSegmentRuntime(segment.runtime)) config.runtime = segment.runtime;
 		if (isRouteSegmentFetchCache(segment.fetchCache)) {
 			const fetchCache = segment.fetchCache;
@@ -205,5 +218,244 @@ function resolveAppRouteHandlerFetchCacheMode(handler) {
 function isEdgeRuntime(runtime) {
 	return isEdgeApiRuntime(runtime);
 }
+/**
+* Resolve a `runtime` from a chain of segment values, outermost first: the
+* last valid value wins, as a child's value wins over its parent's.
+* `collectAppPageStaticGenerationRuntimes` supplies the value Next.js uses to
+* decide whether a page can be statically generated.
+*/
+function resolveAppPageStaticGenerationRuntime(values) {
+	let runtime;
+	for (const value of values) if (isRouteSegmentRuntime(value)) runtime = value;
+	return runtime;
+}
+/**
+* Where the children slot renders its `default` instead of a page: the
+* main-tree position of the folder that owns it. `null` when children renders
+* a page.
+*/
+function resolveChildrenDefaultTreePosition(childrenSlot) {
+	if (!childrenSlot || childrenSlot.state === "active") return null;
+	return treePathDepth(childrenSlot.ownerTreePath);
+}
+function treePathDepth(treePath) {
+	return treePath.split("/").filter(Boolean).length;
+}
+/**
+* The `runtime` Next.js's default build (Turbopack) derives for an App page,
+* for `resolveAppPageStaticGenerationRuntime`. It reads the whole loader tree:
+* at each node the values of every parallel branch (children, matched slots
+* and slots that render `default`) merge, and a conflict fails the build; the
+* node's own layout, page or default module then fills in only an unset value.
+* So an edge slot page next to a Node children page makes the route edge.
+* https://github.com/vercel/next.js/blob/v16.2.7/crates/next-core/src/segment_config.rs#L1323-L1357
+* https://github.com/vercel/next.js/blob/v16.2.7/crates/next-core/src/next_app/app_page_entry.rs#L40-L41
+*/
+function collectAppPageStaticGenerationRuntimes(options) {
+	const segments = collectAppPageStaticParamsWalkSegments(options);
+	const isAt = (segment, treePath) => segment.treePath.length === treePath.length && treePath.every((index, depth) => segment.treePath[depth] === index);
+	const resolveAt = (treePath) => {
+		let runtime;
+		for (const segment of segments) if (segment.treePath.length === treePath.length + 1 && treePath.every((index, depth) => segment.treePath[depth] === index)) runtime = mergeParallelRuntime(runtime, resolveAt(segment.treePath));
+		if (runtime !== void 0) return runtime;
+		const segmentModule = segments.find((segment) => isAt(segment, treePath))?.identity[1];
+		return resolveAppPageStaticGenerationRuntime([segmentModule?.runtime]);
+	};
+	return [resolveAt([])];
+}
+/**
+* Merge a parallel branch's runtime into its siblings'. Next.js fails the
+* build when two siblings set different values; the edge one is kept here,
+* since it keeps the route out of static generation either way.
+*/
+function mergeParallelRuntime(current, sibling) {
+	if (current === void 0) return sibling;
+	if (sibling === void 0 || current === sibling) return current;
+	return isEdgeRuntime(current) ? current : sibling;
+}
+function compareTreePaths(a, b) {
+	if (a.length !== b.length) return a.length - b.length;
+	for (let index = 0; index < a.length; index++) if (a[index] !== b[index]) return a[index] - b[index];
+	return 0;
+}
+/**
+* Whether `generateStaticParams` is exported at or below the route's last
+* dynamic segment: by that segment's layout, a deeper layout, or the page.
+* Next.js classifies such a route as SSG (static generation with an on-demand
+* fallback). A dynamic-segment route without it is dynamic (ƒ) and is never
+* full-page cached.
+*
+* Port of Next.js's `lastDynamicSegmentHadGenerateStaticParams` walk: segments
+* are visited breadth-first, a dynamic segment without `generateStaticParams`
+* clears the flag, and any segment with it sets the flag.
+* https://github.com/vercel/next.js/blob/v16.2.6/packages/next/src/build/static-paths/app.ts#L926-L935
+* https://github.com/vercel/next.js/blob/v16.2.6/packages/next/src/build/segment-config/app/app-segments.ts#L72-L126
+*/
+function lastDynamicSegmentHasGenerateStaticParams(segments) {
+	const visited = [];
+	const ordered = [...segments].sort((a, b) => compareTreePaths(a.treePath, b.treePath));
+	let hasGenerateStaticParams = false;
+	for (const segment of ordered) {
+		const [name, file] = segment.identity;
+		if (visited.some(([seenName, seenFile]) => seenName === name && seenFile === file)) continue;
+		visited.push(segment.identity);
+		if (segment.dynamic && !segment.generateStaticParams) hasGenerateStaticParams = false;
+		else if (segment.generateStaticParams) hasGenerateStaticParams = true;
+	}
+	return hasGenerateStaticParams;
+}
+const PAGE_SEGMENT_NAME = "__PAGE__";
+function hasGenerateStaticParamsExport(segment) {
+	return typeof segment?.generateStaticParams === "function";
+}
+const DEFAULT_SEGMENT_NAME = "__DEFAULT__";
+/**
+* Turbopack reads a folder's subfolders from a `BTreeMap<RcStr, _>`, whose
+* keys compare as Rust `str`s: by UTF-8 bytes. That is Unicode code point
+* order, which JavaScript's `<` (UTF-16 code units) doesn't match above the
+* Basic Multilingual Plane.
+* https://github.com/vercel/next.js/blob/v16.2.7/crates/next-core/src/app_structure.rs#L188-L192
+* https://github.com/vercel/next.js/blob/v16.2.7/turbopack/crates/turbo-rcstr/src/lib.rs#L350-L354
+*/
+function compareFolderNames(a, b) {
+	const left = Array.from(a, (char) => char.codePointAt(0) ?? 0);
+	const right = Array.from(b, (char) => char.codePointAt(0) ?? 0);
+	for (let index = 0; index < Math.min(left.length, right.length); index++) if (left[index] !== right[index]) return left[index] - right[index];
+	return left.length - right.length;
+}
+/**
+* Collect the loader-tree segments of an App page route from its layout, page
+* and parallel-slot modules, for `lastDynamicSegmentHasGenerateStaticParams`.
+*
+* Children follow the loader tree Next.js's default build (Turbopack) makes:
+* `children` first, then every slot in folder-name order, whether it matched
+* a page or renders `default`. A default slot is a single `__DEFAULT__`
+* segment without the slot's layout.
+* https://github.com/vercel/next.js/blob/v16.2.7/crates/next-core/src/app_structure.rs#L1489-L1511
+* https://github.com/vercel/next.js/blob/v16.2.7/crates/next-core/src/app_structure.rs#L1515-L1548
+*/
+function collectAppPageStaticParamsWalkSegments(options) {
+	const childrenDefaultPosition = resolveChildrenDefaultTreePosition(options.childrenSlot);
+	const routeSegments = childrenDefaultPosition === null ? options.routeSegments ?? [] : (options.routeSegments ?? []).slice(0, childrenDefaultPosition);
+	const layoutsByPosition = /* @__PURE__ */ new Map();
+	options.layouts?.forEach((layout, index) => {
+		if (layout) layoutsByPosition.set(options.layoutTreePositions?.[index] ?? 0, layout);
+	});
+	const branchesByOwner = /* @__PURE__ */ new Map();
+	for (const branch of options.parallelBranches ?? []) {
+		if (!branch) continue;
+		const owner = Math.min(branch.ownerTreePosition ?? routeSegments.length - (branch.isDefault ? 0 : (branch.routeSegments ?? []).length), routeSegments.length);
+		branchesByOwner.set(owner, [...branchesByOwner.get(owner) ?? [], branch]);
+	}
+	const segments = [];
+	let treePath = [];
+	for (let position = 0; position <= routeSegments.length + 1; position++) {
+		if (position <= routeSegments.length) {
+			const name = position === 0 ? "" : routeSegments[position - 1];
+			const layout = layoutsByPosition.get(position);
+			segments.push({
+				dynamic: position > 0 && isDynamicSegment(name),
+				generateStaticParams: hasGenerateStaticParamsExport(layout),
+				identity: [name, layout],
+				treePath
+			});
+		} else {
+			segments.push({
+				dynamic: false,
+				generateStaticParams: hasGenerateStaticParamsExport(options.page),
+				identity: [PAGE_SEGMENT_NAME, options.page ?? void 0],
+				treePath
+			});
+			break;
+		}
+		[...branchesByOwner.get(position) ?? []].sort((a, b) => compareFolderNames(a.name ?? "", b.name ?? "")).forEach((branch, index) => {
+			const slotPath = [...treePath, index + 1];
+			if (branch.isDefault) segments.push({
+				dynamic: false,
+				generateStaticParams: hasGenerateStaticParamsExport(branch.page),
+				identity: [DEFAULT_SEGMENT_NAME, branch.page ?? void 0],
+				treePath: slotPath
+			});
+			else segments.push(...collectActiveSlotSegments(branch, slotPath));
+		});
+		if (position === childrenDefaultPosition) {
+			segments.push({
+				dynamic: false,
+				generateStaticParams: hasGenerateStaticParamsExport(options.page),
+				identity: [DEFAULT_SEGMENT_NAME, options.page ?? void 0],
+				treePath: [...treePath, 0]
+			});
+			break;
+		}
+		treePath = [...treePath, 0];
+	}
+	return segments;
+}
+function collectActiveSlotSegments(branch, slotPath) {
+	const branchSegments = branch.routeSegments ?? [];
+	const configLayoutsByPosition = /* @__PURE__ */ new Map();
+	branch.configLayouts?.forEach((layout, index) => {
+		if (layout) configLayoutsByPosition.set(branch.configLayoutTreePositions?.[index] ?? 0, layout);
+	});
+	const segments = [{
+		dynamic: false,
+		generateStaticParams: hasGenerateStaticParamsExport(branch.layout),
+		identity: [`@${branch.name ?? ""}`, branch.layout ?? void 0],
+		treePath: slotPath
+	}];
+	const depth = Math.max(branchSegments.length, ...branch.configLayoutTreePositions ?? []);
+	let treePath = [...slotPath];
+	for (let index = 0; index < depth; index++) {
+		treePath = [...treePath, 0];
+		const name = branchSegments[index];
+		const layout = configLayoutsByPosition.get(index + 1);
+		segments.push({
+			dynamic: name !== void 0 && isDynamicSegment(name),
+			generateStaticParams: hasGenerateStaticParamsExport(layout),
+			identity: [name ?? "", layout],
+			treePath
+		});
+	}
+	segments.push({
+		dynamic: false,
+		generateStaticParams: hasGenerateStaticParamsExport(branch.page),
+		identity: [PAGE_SEGMENT_NAME, branch.page ?? void 0],
+		treePath: [...treePath, 0]
+	});
+	return segments;
+}
+/**
+* Whether an App page route exports `generateStaticParams` at or below its last
+* dynamic segment, read from its layout, page and parallel-slot modules.
+*/
+function hasAppPageGenerateStaticParamsAtLastDynamicSegment(options) {
+	return lastDynamicSegmentHasGenerateStaticParams(collectAppPageStaticParamsWalkSegments(options));
+}
+/**
+* Whether Next.js would classify an App page route as static or SSG from its
+* config alone. Only such routes are full-page cache candidates; every other
+* route renders per request with real values and is never ISR-cached.
+*
+* - `runtime = "edge"` disables static generation, whatever else the route
+*   sets.
+* - `dynamic = "force-dynamic"` and `revalidate = 0` are dynamic.
+* - `dynamic = "force-static"` and `dynamic = "error"` are static.
+* - Otherwise a route is static when it has no dynamic segments, or when
+*   `generateStaticParams` sits at or below its last dynamic segment.
+*
+* Next.js also treats a route as SSG when an ancestor's `generateStaticParams`
+* returns every pathname param (`hadAllParamsGenerated`). That depends on the
+* generator's output, which vinext doesn't compute per request, so such a
+* route is treated as dynamic here. Adding `generateStaticParams` to the last
+* dynamic segment (even returning `[]`) opts it in, on both.
+*
+* https://github.com/vercel/next.js/blob/v16.2.6/packages/next/src/build/index.ts#L2333-L2408
+*/
+function isAppPageStaticEligible(options) {
+	if (options.isStaticGenerationEdgeRuntime) return false;
+	if (options.dynamicConfig === "force-dynamic" || options.revalidateSeconds === 0) return false;
+	if (options.dynamicConfig === "force-static" || options.dynamicConfig === "error") return true;
+	return !options.isDynamicRoute || options.hasGenerateStaticParams;
+}
 //#endregion
-export { isEdgeRuntime, resolveAppPageFetchCacheMode, resolveAppPageSegmentConfig, resolveAppRouteHandlerFetchCacheMode };
+export { collectAppPageStaticGenerationRuntimes, collectAppPageStaticParamsWalkSegments, hasAppPageGenerateStaticParamsAtLastDynamicSegment, isAppPageStaticEligible, isEdgeRuntime, lastDynamicSegmentHasGenerateStaticParams, resolveAppPageDynamicConfig, resolveAppPageFetchCacheMode, resolveAppPageSegmentConfig, resolveAppPageStaticGenerationRuntime, resolveAppRouteHandlerFetchCacheMode };

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

@@ -1,11 +1,12 @@
 import { AppRscRenderMode } from "./app-rsc-render-mode.js";
 import { ActionRevalidationKind } from "../shims/cache-request-state.js";
+import { AppRenderErrorContextOverrides } from "./app-rsc-error-handler.js";
 import { FetchCacheMode } from "../shims/fetch-cache.js";
 import { HeadersAccessPhase } from "../shims/headers.js";
 import { ReactFormState } from "react-dom/client";
 //#region src/server/app-server-action-execution.d.ts
 type AppPageParams = Record<string, string | string[]>;
-type AppServerActionErrorReporter = (error: Error, request: {
+type AppServerActionErrorReporter = (error: unknown, request: {
   path: string;
   method: string;
   headers: Record<string, string>;
@@ -13,6 +14,8 @@ type AppServerActionErrorReporter = (error: Error, request: {
   routerKind: "App Router";
   routePath: string;
   routeType: "action";
+  renderSource: "react-server-components-payload";
+  revalidateReason: undefined;
 }) => void;
 type AppServerActionDecoder = (body: FormData) => Promise<unknown>;
 type AppServerActionFormStateDecoder = (actionResult: unknown, body: FormData) => Promise<ReactFormState | undefined>;
@@ -103,6 +106,7 @@ type BuildServerActionPageElementOptions<TRoute extends AppServerActionRoute, TI
   searchParams: URLSearchParams;
   scriptNonce?: string;
   renderMode: AppRscRenderMode;
+  isForceStatic?: boolean;
   observeMetadataSearchParamsAccess?: boolean;
   observePageSearchParamsAccess?: boolean;
 };
@@ -122,7 +126,7 @@ type RenderServerActionRscStreamOptions<TTemporaryReferences> = {
 type DecodeServerActionReplyOptions<TTemporaryReferences> = {
   temporaryReferences: TTemporaryReferences;
 };
-type HandleProgressiveServerActionRequestOptions = {
+export type HandleProgressiveServerActionRequestOptions = {
   actionId: string | null;
   allowedOrigins: string[];
   /** Configured next.config `basePath`. Prefixed onto progressive Location targets. */
@@ -150,9 +154,10 @@ type HandleProgressiveServerActionRequestOptions = {
   readFormDataWithLimit: ReadFormDataWithLimit;
   reportRequestError: AppServerActionErrorReporter;
   request: Request;
+  routePattern: string;
   setHeadersAccessPhase: (phase: HeadersAccessPhase) => HeadersAccessPhase;
 };
-type HandleServerActionRscRequestOptions<TElement, TRoute extends AppServerActionRoute, TInterceptOpts, TTemporaryReferences, TPage = unknown> = {
+export type HandleServerActionRscRequestOptions<TElement, TRoute extends AppServerActionRoute, TInterceptOpts, TTemporaryReferences, TPage = unknown> = {
   actionId: string | null;
   allowedOrigins: string[];
   /** Configured next.config `basePath`. Prefixed onto ACTION_REDIRECT_HEADER targets. */
@@ -167,7 +172,7 @@ type HandleServerActionRscRequestOptions<TElement, TRoute extends AppServerActio
   currentRoutePathname: string;
   createNotFoundElement: (routeId: string) => TElement;
   createPayloadRouteId: (pathname: string, interceptionContext: string | null) => string;
-  createRscOnErrorHandler: (request: Request, pathname: string, pattern: string) => (error: unknown) => unknown;
+  createRscOnErrorHandler: (request: Request, pathname: string, pattern: string, overrides?: AppRenderErrorContextOverrides) => (error: unknown) => unknown;
   createTemporaryReferenceSet: () => TTemporaryReferences;
   decodeReply: (body: string | FormData, options: DecodeServerActionReplyOptions<TTemporaryReferences>) => Promise<unknown[]> | unknown[];
   draftModeSecret: string;
@@ -229,8 +234,8 @@ type HandleServerActionRscRequestOptions<TElement, TRoute extends AppServerActio
   }) => void;
   toInterceptOpts: (intercept: AppServerActionIntercept<TPage>) => TInterceptOpts;
 };
-declare function readActionBodyWithLimit(request: Request, maxBytes: number): Promise<string>;
-declare function readActionFormDataWithLimit(request: Request, maxBytes: number): Promise<FormData>;
+export declare function readActionBodyWithLimit(request: Request, maxBytes: number): Promise<string>;
+export declare function readActionFormDataWithLimit(request: Request, maxBytes: number): Promise<FormData>;
 /**
  * Prepend the configured next.config `basePath` to a server-action redirect
  * target before it goes on the wire.
@@ -254,9 +259,8 @@ declare function readActionFormDataWithLimit(request: Request, maxBytes: number)
  *
  * @see https://github.com/vercel/next.js/blob/canary/packages/next/src/server/app-render/action-handler.ts
  */
-declare function applyActionRedirectBasePath(url: string, basePath: string): string;
-declare function isProgressiveServerActionRequest(request: Pick<Request, "method">, contentType: string, actionId: string | null): boolean;
-declare function handleProgressiveServerActionRequest(options: HandleProgressiveServerActionRequestOptions): Promise<Response | ProgressiveServerActionResult | null>;
-declare function handleServerActionRscRequest<TElement, TRoute extends AppServerActionRoute, TInterceptOpts, TTemporaryReferences, TPage = unknown>(options: HandleServerActionRscRequestOptions<TElement, TRoute, TInterceptOpts, TTemporaryReferences, TPage>): Promise<Response | null>;
-//#endregion
-export { HandleProgressiveServerActionRequestOptions, HandleServerActionRscRequestOptions, applyActionRedirectBasePath, handleProgressiveServerActionRequest, handleServerActionRscRequest, isProgressiveServerActionRequest, readActionBodyWithLimit, readActionFormDataWithLimit };
+export declare function applyActionRedirectBasePath(url: string, basePath: string): string;
+export declare function isProgressiveServerActionRequest(request: Pick<Request, "method">, contentType: string, actionId: string | null): boolean;
+export declare function handleProgressiveServerActionRequest(options: HandleProgressiveServerActionRequestOptions): Promise<Response | ProgressiveServerActionResult | null>;
+export declare function handleServerActionRscRequest<TElement, TRoute extends AppServerActionRoute, TInterceptOpts, TTemporaryReferences, TPage = unknown>(options: HandleServerActionRscRequestOptions<TElement, TRoute, TInterceptOpts, TTemporaryReferences, TPage>): Promise<Response | null>;
+//#endregion