vinext 0.0.45 → 0.0.47

package/dist/server/app-rsc-response-finalizer.d.ts

@@ -0,0 +1,30 @@
+import { NextHeader } from "../config/next-config.js";
+import { RequestContext } from "../config/config-matchers.js";
+
+//#region src/server/app-rsc-response-finalizer.d.ts
+type FinalizeAppRscResponseOptions = {
+  basePath: string;
+  configHeaders: NextHeader[];
+  /**
+   * Original pre-middleware request context.
+   * Next.js evaluates config header has/missing conditions against the
+   * unmodified incoming request, so callers must pass the snapshot taken
+   * before middleware runs.
+   */
+  requestContext: RequestContext;
+};
+/**
+ * Apply next.config.js response headers to an App Router response.
+ *
+ * Called once per request in the outer handler() wrapper, after all route
+ * handling, so that every response path (page, route handler, server action,
+ * metadata, not-found) gets headers applied consistently.
+ *
+ * Skips 3xx redirect responses. Response.redirect() creates immutable
+ * headers that throw on mutation, and Next.js does not apply config headers
+ * to redirects regardless.
+ */
+declare function finalizeAppRscResponse(response: Response, request: Request, options: FinalizeAppRscResponseOptions): Response;
+//#endregion
+export { finalizeAppRscResponse };
+//# sourceMappingURL=app-rsc-response-finalizer.d.ts.map

package/dist/server/app-rsc-response-finalizer.js

@@ -0,0 +1,38 @@
+import { normalizePathnameForRouteMatch } from "../routing/utils.js";
+import { normalizePath } from "./normalize-path.js";
+import { stripBasePath } from "../utils/base-path.js";
+import { applyConfigHeadersToResponse } from "./request-pipeline.js";
+//#region src/server/app-rsc-response-finalizer.ts
+/**
+* Apply next.config.js response headers to an App Router response.
+*
+* Called once per request in the outer handler() wrapper, after all route
+* handling, so that every response path (page, route handler, server action,
+* metadata, not-found) gets headers applied consistently.
+*
+* Skips 3xx redirect responses. Response.redirect() creates immutable
+* headers that throw on mutation, and Next.js does not apply config headers
+* to redirects regardless.
+*/
+function finalizeAppRscResponse(response, request, options) {
+	if (response.status >= 300 && response.status < 400) return response;
+	if (!options.configHeaders.length) return response;
+	const url = new URL(request.url);
+	let pathname;
+	try {
+		pathname = normalizePath(normalizePathnameForRouteMatch(url.pathname));
+	} catch {
+		pathname = url.pathname;
+	}
+	pathname = stripBasePath(pathname, options.basePath);
+	applyConfigHeadersToResponse(response.headers, {
+		configHeaders: options.configHeaders,
+		pathname,
+		requestContext: options.requestContext
+	});
+	return response;
+}
+//#endregion
+export { finalizeAppRscResponse };
+
+//# sourceMappingURL=app-rsc-response-finalizer.js.map

package/dist/server/app-rsc-response-finalizer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"app-rsc-response-finalizer.js","names":[],"sources":["../../src/server/app-rsc-response-finalizer.ts"],"sourcesContent":["import type { NextHeader } from \"../config/next-config.js\";\nimport type { RequestContext } from \"../config/config-matchers.js\";\nimport { applyConfigHeadersToResponse } from \"./request-pipeline.js\";\nimport { stripBasePath } from \"../utils/base-path.js\";\nimport { normalizePath } from \"./normalize-path.js\";\nimport { normalizePathnameForRouteMatch } from \"../routing/utils.js\";\n\ntype FinalizeAppRscResponseOptions = {\n  basePath: string;\n  configHeaders: NextHeader[];\n  /**\n   * Original pre-middleware request context.\n   * Next.js evaluates config header has/missing conditions against the\n   * unmodified incoming request, so callers must pass the snapshot taken\n   * before middleware runs.\n   */\n  requestContext: RequestContext;\n};\n\n/**\n * Apply next.config.js response headers to an App Router response.\n *\n * Called once per request in the outer handler() wrapper, after all route\n * handling, so that every response path (page, route handler, server action,\n * metadata, not-found) gets headers applied consistently.\n *\n * Skips 3xx redirect responses. Response.redirect() creates immutable\n * headers that throw on mutation, and Next.js does not apply config headers\n * to redirects regardless.\n */\nexport function finalizeAppRscResponse(\n  response: Response,\n  request: Request,\n  options: FinalizeAppRscResponseOptions,\n): Response {\n  // 3xx responses: Response.redirect() headers are immutable (throws on write),\n  // and Next.js deliberately excludes config headers from redirect responses.\n  if (response.status >= 300 && response.status < 400) {\n    return response;\n  }\n\n  if (!options.configHeaders.length) {\n    return response;\n  }\n\n  const url = new URL(request.url);\n  let pathname: string;\n  try {\n    pathname = normalizePath(normalizePathnameForRouteMatch(url.pathname));\n  } catch {\n    // Malformed percent-encoding. The request reached this point only because\n    // normalizePathnameForRouteMatchStrict ran earlier and returned 400 for\n    // truly-malformed paths. This catch exists as a safety net for edge cases;\n    // keep the historical raw-path fallback rather than crashing the response.\n    pathname = url.pathname;\n  }\n\n  // Config header sources are defined without basePath prefix. Strip basePath\n  // at a segment boundary (not a string prefix) so /app2/page with basePath\n  // /app is not incorrectly treated as /app with suffix /2/page.\n  pathname = stripBasePath(pathname, options.basePath);\n\n  applyConfigHeadersToResponse(response.headers, {\n    configHeaders: options.configHeaders,\n    pathname,\n    requestContext: options.requestContext,\n  });\n\n  return response;\n}\n"],"mappings":";;;;;;;;;;;;;;;;AA8BA,SAAgB,uBACd,UACA,SACA,SACU;AAGV,KAAI,SAAS,UAAU,OAAO,SAAS,SAAS,IAC9C,QAAO;AAGT,KAAI,CAAC,QAAQ,cAAc,OACzB,QAAO;CAGT,MAAM,MAAM,IAAI,IAAI,QAAQ,IAAI;CAChC,IAAI;AACJ,KAAI;AACF,aAAW,cAAc,+BAA+B,IAAI,SAAS,CAAC;SAChE;AAKN,aAAW,IAAI;;AAMjB,YAAW,cAAc,UAAU,QAAQ,SAAS;AAEpD,8BAA6B,SAAS,SAAS;EAC7C,eAAe,QAAQ;EACvB;EACA,gBAAgB,QAAQ;EACzB,CAAC;AAEF,QAAO"}

package/dist/server/app-rsc-route-matching.d.ts

@@ -0,0 +1,40 @@
+import { RoutePatternParams } from "../routing/route-pattern.js";
+
+//#region src/server/app-rsc-route-matching.d.ts
+type AppRscRouteParams = RoutePatternParams;
+type AppRscInterceptForMatching = {
+  targetPattern: string;
+  interceptLayouts: readonly unknown[];
+  page: unknown;
+  params: readonly string[];
+};
+type AppRscSlotForMatching = {
+  intercepts?: readonly AppRscInterceptForMatching[];
+};
+type AppRscRouteForMatching = {
+  patternParts: string[];
+  slots?: Record<string, AppRscSlotForMatching>;
+};
+type AppRscInterceptMatch = AppRscInterceptLookupEntry & {
+  matchedParams: AppRscRouteParams;
+};
+type AppRscInterceptLookupEntry = {
+  sourceRouteIndex: number;
+  slotKey: string;
+  targetPattern: string;
+  targetPatternParts: string[];
+  interceptLayouts: readonly unknown[];
+  page: unknown;
+  params: readonly string[];
+};
+declare function createAppRscRouteMatcher<Route extends AppRscRouteForMatching>(routes: Route[]): {
+  matchRoute(url: string): {
+    route: Route;
+    params: AppRscRouteParams;
+  } | null;
+  findIntercept(pathname: string, sourcePathname?: string | null): AppRscInterceptMatch | null;
+};
+declare function matchAppRscRoutePattern(urlParts: string[], patternParts: string[]): AppRscRouteParams | null;
+//#endregion
+export { createAppRscRouteMatcher, matchAppRscRoutePattern };
+//# sourceMappingURL=app-rsc-route-matching.d.ts.map

package/dist/server/app-rsc-route-matching.js

@@ -0,0 +1,66 @@
+import { buildRouteTrie, trieMatch } from "../routing/route-trie.js";
+import { matchRoutePattern } from "../routing/route-pattern.js";
+//#region src/server/app-rsc-route-matching.ts
+function createRouteParams() {
+	return Object.create(null);
+}
+function createAppRscRouteMatcher(routes) {
+	const routeTrie = buildRouteTrie(routes);
+	const interceptLookup = createInterceptLookup(routes);
+	return {
+		matchRoute(url) {
+			const pathname = url.split("?")[0];
+			return trieMatch(routeTrie, (pathname === "/" ? "/" : pathname.replace(/\/$/, "")).split("/").filter(Boolean));
+		},
+		findIntercept(pathname, sourcePathname = null) {
+			const urlParts = pathname.split("/").filter(Boolean);
+			for (const entry of interceptLookup) {
+				const params = matchAppRscRoutePattern(urlParts, entry.targetPatternParts);
+				if (params !== null) {
+					let sourceParams = createRouteParams();
+					if (sourcePathname !== null) {
+						const sourceRoute = routes[entry.sourceRouteIndex];
+						const sourceParts = sourcePathname.split("/").filter(Boolean);
+						const matchedSourceParams = sourceRoute ? matchAppRscRoutePattern(sourceParts, sourceRoute.patternParts) : null;
+						if (matchedSourceParams !== null) sourceParams = matchedSourceParams;
+					}
+					return {
+						...entry,
+						matchedParams: mergeMatchedParams(sourceParams, params)
+					};
+				}
+			}
+			return null;
+		}
+	};
+}
+function createInterceptLookup(routes) {
+	const interceptLookup = [];
+	for (let routeIndex = 0; routeIndex < routes.length; routeIndex++) {
+		const route = routes[routeIndex];
+		if (!route.slots) continue;
+		for (const [slotKey, slotModule] of Object.entries(route.slots)) {
+			if (!slotModule.intercepts) continue;
+			for (const intercept of slotModule.intercepts) interceptLookup.push({
+				sourceRouteIndex: routeIndex,
+				slotKey,
+				targetPattern: intercept.targetPattern,
+				targetPatternParts: intercept.targetPattern.split("/").filter(Boolean),
+				interceptLayouts: intercept.interceptLayouts,
+				page: intercept.page,
+				params: intercept.params
+			});
+		}
+	}
+	return interceptLookup;
+}
+function matchAppRscRoutePattern(urlParts, patternParts) {
+	return matchRoutePattern(urlParts, patternParts);
+}
+function mergeMatchedParams(sourceParams, targetParams) {
+	return Object.assign(createRouteParams(), sourceParams, targetParams);
+}
+//#endregion
+export { createAppRscRouteMatcher, matchAppRscRoutePattern };
+
+//# sourceMappingURL=app-rsc-route-matching.js.map

package/dist/server/app-rsc-route-matching.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"app-rsc-route-matching.js","names":[],"sources":["../../src/server/app-rsc-route-matching.ts"],"sourcesContent":["import { buildRouteTrie, trieMatch } from \"../routing/route-trie.js\";\nimport { matchRoutePattern, type RoutePatternParams } from \"../routing/route-pattern.js\";\n\ntype AppRscRouteParams = RoutePatternParams;\n\ntype AppRscInterceptForMatching = {\n  targetPattern: string;\n  interceptLayouts: readonly unknown[];\n  page: unknown;\n  params: readonly string[];\n};\n\ntype AppRscSlotForMatching = {\n  intercepts?: readonly AppRscInterceptForMatching[];\n};\n\ntype AppRscRouteForMatching = {\n  patternParts: string[];\n  slots?: Record<string, AppRscSlotForMatching>;\n};\n\ntype AppRscInterceptMatch = AppRscInterceptLookupEntry & {\n  matchedParams: AppRscRouteParams;\n};\n\ntype AppRscInterceptLookupEntry = {\n  sourceRouteIndex: number;\n  slotKey: string;\n  targetPattern: string;\n  targetPatternParts: string[];\n  interceptLayouts: readonly unknown[];\n  page: unknown;\n  params: readonly string[];\n};\n\nfunction createRouteParams(): AppRscRouteParams {\n  return Object.create(null);\n}\n\nexport function createAppRscRouteMatcher<Route extends AppRscRouteForMatching>(\n  routes: Route[],\n): {\n  matchRoute(url: string): { route: Route; params: AppRscRouteParams } | null;\n  findIntercept(pathname: string, sourcePathname?: string | null): AppRscInterceptMatch | null;\n} {\n  const routeTrie = buildRouteTrie(routes);\n  const interceptLookup = createInterceptLookup(routes);\n\n  return {\n    matchRoute(url) {\n      const pathname = url.split(\"?\")[0];\n      const normalizedUrl = pathname === \"/\" ? \"/\" : pathname.replace(/\\/$/, \"\");\n      // The request entry point owns decoding. Matching here preserves the\n      // already-normalized segment bytes so middleware and routing stay aligned.\n      const urlParts = normalizedUrl.split(\"/\").filter(Boolean);\n      return trieMatch(routeTrie, urlParts);\n    },\n    findIntercept(pathname, sourcePathname = null) {\n      const urlParts = pathname.split(\"/\").filter(Boolean);\n      for (const entry of interceptLookup) {\n        const params = matchAppRscRoutePattern(urlParts, entry.targetPatternParts);\n        if (params !== null) {\n          let sourceParams = createRouteParams();\n          if (sourcePathname !== null) {\n            const sourceRoute = routes[entry.sourceRouteIndex];\n            const sourceParts = sourcePathname.split(\"/\").filter(Boolean);\n            const matchedSourceParams = sourceRoute\n              ? matchAppRscRoutePattern(sourceParts, sourceRoute.patternParts)\n              : null;\n            if (matchedSourceParams !== null) {\n              sourceParams = matchedSourceParams;\n            }\n          }\n          return { ...entry, matchedParams: mergeMatchedParams(sourceParams, params) };\n        }\n      }\n      return null;\n    },\n  };\n}\n\nfunction createInterceptLookup<Route extends AppRscRouteForMatching>(\n  routes: Route[],\n): AppRscInterceptLookupEntry[] {\n  const interceptLookup: AppRscInterceptLookupEntry[] = [];\n  for (let routeIndex = 0; routeIndex < routes.length; routeIndex++) {\n    const route = routes[routeIndex];\n    if (!route.slots) continue;\n    for (const [slotKey, slotModule] of Object.entries(route.slots)) {\n      if (!slotModule.intercepts) continue;\n      for (const intercept of slotModule.intercepts) {\n        interceptLookup.push({\n          sourceRouteIndex: routeIndex,\n          slotKey,\n          targetPattern: intercept.targetPattern,\n          targetPatternParts: intercept.targetPattern.split(\"/\").filter(Boolean),\n          interceptLayouts: intercept.interceptLayouts,\n          page: intercept.page,\n          params: intercept.params,\n        });\n      }\n    }\n  }\n  return interceptLookup;\n}\n\nexport function matchAppRscRoutePattern(\n  urlParts: string[],\n  patternParts: string[],\n): AppRscRouteParams | null {\n  return matchRoutePattern(urlParts, patternParts);\n}\n\nfunction mergeMatchedParams(\n  sourceParams: AppRscRouteParams,\n  targetParams: AppRscRouteParams,\n): AppRscRouteParams {\n  return Object.assign(createRouteParams(), sourceParams, targetParams);\n}\n"],"mappings":";;;AAmCA,SAAS,oBAAuC;AAC9C,QAAO,OAAO,OAAO,KAAK;;AAG5B,SAAgB,yBACd,QAIA;CACA,MAAM,YAAY,eAAe,OAAO;CACxC,MAAM,kBAAkB,sBAAsB,OAAO;AAErD,QAAO;EACL,WAAW,KAAK;GACd,MAAM,WAAW,IAAI,MAAM,IAAI,CAAC;AAKhC,UAAO,UAAU,YAJK,aAAa,MAAM,MAAM,SAAS,QAAQ,OAAO,GAAG,EAG3C,MAAM,IAAI,CAAC,OAAO,QAAQ,CACpB;;EAEvC,cAAc,UAAU,iBAAiB,MAAM;GAC7C,MAAM,WAAW,SAAS,MAAM,IAAI,CAAC,OAAO,QAAQ;AACpD,QAAK,MAAM,SAAS,iBAAiB;IACnC,MAAM,SAAS,wBAAwB,UAAU,MAAM,mBAAmB;AAC1E,QAAI,WAAW,MAAM;KACnB,IAAI,eAAe,mBAAmB;AACtC,SAAI,mBAAmB,MAAM;MAC3B,MAAM,cAAc,OAAO,MAAM;MACjC,MAAM,cAAc,eAAe,MAAM,IAAI,CAAC,OAAO,QAAQ;MAC7D,MAAM,sBAAsB,cACxB,wBAAwB,aAAa,YAAY,aAAa,GAC9D;AACJ,UAAI,wBAAwB,KAC1B,gBAAe;;AAGnB,YAAO;MAAE,GAAG;MAAO,eAAe,mBAAmB,cAAc,OAAO;MAAE;;;AAGhF,UAAO;;EAEV;;AAGH,SAAS,sBACP,QAC8B;CAC9B,MAAM,kBAAgD,EAAE;AACxD,MAAK,IAAI,aAAa,GAAG,aAAa,OAAO,QAAQ,cAAc;EACjE,MAAM,QAAQ,OAAO;AACrB,MAAI,CAAC,MAAM,MAAO;AAClB,OAAK,MAAM,CAAC,SAAS,eAAe,OAAO,QAAQ,MAAM,MAAM,EAAE;AAC/D,OAAI,CAAC,WAAW,WAAY;AAC5B,QAAK,MAAM,aAAa,WAAW,WACjC,iBAAgB,KAAK;IACnB,kBAAkB;IAClB;IACA,eAAe,UAAU;IACzB,oBAAoB,UAAU,cAAc,MAAM,IAAI,CAAC,OAAO,QAAQ;IACtE,kBAAkB,UAAU;IAC5B,MAAM,UAAU;IAChB,QAAQ,UAAU;IACnB,CAAC;;;AAIR,QAAO;;AAGT,SAAgB,wBACd,UACA,cAC0B;AAC1B,QAAO,kBAAkB,UAAU,aAAa;;AAGlD,SAAS,mBACP,cACA,cACmB;AACnB,QAAO,OAAO,OAAO,mBAAmB,EAAE,cAAc,aAAa"}

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

@@ -0,0 +1,33 @@
+import { FetchCacheMode } from "../shims/fetch-cache.js";
+
+//#region src/server/app-segment-config.d.ts
+type AppRouteSegmentDynamic = "auto" | "error" | "force-dynamic" | "force-static";
+type AppRouteSegmentConfigModule = {
+  dynamic?: unknown;
+  dynamicParams?: unknown;
+  fetchCache?: unknown;
+  revalidate?: unknown;
+};
+type EffectiveAppPageSegmentConfig = {
+  dynamicConfig?: AppRouteSegmentDynamic;
+  dynamicParamsConfig?: boolean;
+  fetchCache?: FetchCacheMode;
+  revalidateSeconds: number | null;
+};
+type ResolveAppPageSegmentConfigOptions = {
+  layouts?: readonly (AppRouteSegmentConfigModule | null | undefined)[];
+  page?: AppRouteSegmentConfigModule | null;
+};
+/**
+ * Resolve the route segment config that applies to an App page route.
+ *
+ * Next.js collects config from every segment in the loader tree and reduces it
+ * into the effective route config. The generated vinext entry already knows
+ * 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;
+//#endregion
+export { resolveAppPageFetchCacheMode, resolveAppPageSegmentConfig };
+//# sourceMappingURL=app-segment-config.d.ts.map

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

@@ -0,0 +1,86 @@
+//#region src/server/app-segment-config.ts
+const DYNAMIC_VALUES = new Set([
+	"auto",
+	"error",
+	"force-dynamic",
+	"force-static"
+]);
+const FETCH_CACHE_VALUES = new Set([
+	"auto",
+	"default-cache",
+	"default-no-store",
+	"force-cache",
+	"force-no-store",
+	"only-cache",
+	"only-no-store"
+]);
+function isRouteSegmentDynamic(value) {
+	return DYNAMIC_VALUES.has(value);
+}
+function isRouteSegmentFetchCache(value) {
+	return FETCH_CACHE_VALUES.has(value);
+}
+function resolveRevalidateSeconds(current, value) {
+	if (typeof value !== "number") return current;
+	if (current === null) return value;
+	return value < current ? value : current;
+}
+function isCacheFetchCacheMode(value) {
+	return value === "default-cache" || value === "force-cache" || value === "only-cache";
+}
+function describeFetchCacheConflict(value) {
+	return `Route segment config has incompatible fetchCache values including "${value}".`;
+}
+/**
+* Resolve the route segment config that applies to an App page route.
+*
+* Next.js collects config from every segment in the loader tree and reduces it
+* into the effective route config. The generated vinext entry already knows
+* the concrete layout/page modules for a route, so it should only describe
+* those modules and delegate the behavior to this helper.
+*/
+function resolveAppPageSegmentConfig(options) {
+	const segments = [...options.layouts ?? [], options.page];
+	const config = { revalidateSeconds: null };
+	let hasForceCache = false;
+	let hasForceNoStore = false;
+	let hasOnlyCache = false;
+	let hasOnlyNoStore = false;
+	let hasParentDefaultNoStore = false;
+	for (const segment of segments) {
+		if (!segment) continue;
+		if (isRouteSegmentDynamic(segment.dynamic)) config.dynamicConfig = segment.dynamic;
+		if (segment.dynamicParams === false) config.dynamicParamsConfig = false;
+		else if (segment.dynamicParams === true && config.dynamicParamsConfig !== false) config.dynamicParamsConfig = true;
+		if (isRouteSegmentFetchCache(segment.fetchCache)) {
+			const fetchCache = segment.fetchCache;
+			if (hasParentDefaultNoStore && (fetchCache === "auto" || isCacheFetchCacheMode(fetchCache))) throw new Error(describeFetchCacheConflict(fetchCache));
+			if (fetchCache === "force-cache") hasForceCache = true;
+			if (fetchCache === "force-no-store") hasForceNoStore = true;
+			if (fetchCache === "only-cache") hasOnlyCache = true;
+			if (fetchCache === "only-no-store") hasOnlyNoStore = true;
+			if ((hasForceCache || hasOnlyCache) && (hasForceNoStore || hasOnlyNoStore)) throw new Error(describeFetchCacheConflict(fetchCache));
+			if (fetchCache === "default-no-store") hasParentDefaultNoStore = true;
+			if (hasForceCache) config.fetchCache = "force-cache";
+			else if (hasForceNoStore) config.fetchCache = "force-no-store";
+			else if (hasOnlyCache) config.fetchCache = "only-cache";
+			else if (hasOnlyNoStore) config.fetchCache = "only-no-store";
+			else config.fetchCache = fetchCache;
+		}
+		config.revalidateSeconds = resolveRevalidateSeconds(config.revalidateSeconds, segment.revalidate);
+	}
+	if (config.dynamicConfig === "force-dynamic") config.revalidateSeconds = 0;
+	if (config.fetchCache === void 0) {
+		if (config.dynamicConfig === "force-dynamic") config.fetchCache = "force-no-store";
+		else if (config.dynamicConfig === "error") config.fetchCache = "only-cache";
+	}
+	if (config.dynamicParamsConfig === void 0 && (config.dynamicConfig === "error" || config.dynamicConfig === "force-static")) config.dynamicParamsConfig = false;
+	return config;
+}
+function resolveAppPageFetchCacheMode(options) {
+	return resolveAppPageSegmentConfig(options).fetchCache ?? null;
+}
+//#endregion
+export { resolveAppPageFetchCacheMode, resolveAppPageSegmentConfig };
+
+//# sourceMappingURL=app-segment-config.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"app-segment-config.js","names":[],"sources":["../../src/server/app-segment-config.ts"],"sourcesContent":["import type { FetchCacheMode } from \"vinext/shims/fetch-cache\";\n\ntype AppRouteSegmentDynamic = \"auto\" | \"error\" | \"force-dynamic\" | \"force-static\";\n\ntype AppRouteSegmentConfigModule = {\n  dynamic?: unknown;\n  dynamicParams?: unknown;\n  fetchCache?: unknown;\n  revalidate?: unknown;\n};\n\ntype EffectiveAppPageSegmentConfig = {\n  dynamicConfig?: AppRouteSegmentDynamic;\n  dynamicParamsConfig?: boolean;\n  fetchCache?: FetchCacheMode;\n  revalidateSeconds: number | null;\n};\n\ntype ResolveAppPageSegmentConfigOptions = {\n  layouts?: readonly (AppRouteSegmentConfigModule | null | undefined)[];\n  page?: AppRouteSegmentConfigModule | null;\n};\n\nconst DYNAMIC_VALUES = new Set<unknown>([\"auto\", \"error\", \"force-dynamic\", \"force-static\"]);\nconst FETCH_CACHE_VALUES = new Set<unknown>([\n  \"auto\",\n  \"default-cache\",\n  \"default-no-store\",\n  \"force-cache\",\n  \"force-no-store\",\n  \"only-cache\",\n  \"only-no-store\",\n]);\n\nfunction isRouteSegmentDynamic(value: unknown): value is AppRouteSegmentDynamic {\n  return DYNAMIC_VALUES.has(value);\n}\n\nfunction isRouteSegmentFetchCache(value: unknown): value is FetchCacheMode {\n  return FETCH_CACHE_VALUES.has(value);\n}\n\nfunction resolveRevalidateSeconds(current: number | null, value: unknown): number | null {\n  // TODO: Next.js also accepts `revalidate = false` for indefinite caching.\n  // Existing vinext code ignores non-numeric values; keep that behavior until\n  // the cache layer can represent \"cache forever\" distinctly from \"unset\".\n  if (typeof value !== \"number\") {\n    return current;\n  }\n\n  if (current === null) {\n    return value;\n  }\n\n  return value < current ? value : current;\n}\n\nfunction isCacheFetchCacheMode(value: FetchCacheMode): boolean {\n  return value === \"default-cache\" || value === \"force-cache\" || value === \"only-cache\";\n}\n\nfunction describeFetchCacheConflict(value: FetchCacheMode): string {\n  return `Route segment config has incompatible fetchCache values including \"${value}\".`;\n}\n\n/**\n * Resolve the route segment config that applies to an App page route.\n *\n * Next.js collects config from every segment in the loader tree and reduces it\n * into the effective route config. The generated vinext entry already knows\n * the concrete layout/page modules for a route, so it should only describe\n * those modules and delegate the behavior to this helper.\n */\nexport function resolveAppPageSegmentConfig(\n  options: ResolveAppPageSegmentConfigOptions,\n): EffectiveAppPageSegmentConfig {\n  const segments = [...(options.layouts ?? []), options.page];\n  // Reduction strategies differ by field:\n  // - dynamic: child segments override parents.\n  // - dynamicParams: false is sticky across the route tree.\n  // - fetchCache: force/only modes take route-level precedence and reject conflicts.\n  // - revalidate: the shortest numeric interval wins.\n  const config: EffectiveAppPageSegmentConfig = {\n    revalidateSeconds: null,\n  };\n  let hasForceCache = false;\n  let hasForceNoStore = false;\n  let hasOnlyCache = false;\n  let hasOnlyNoStore = false;\n  let hasParentDefaultNoStore = false;\n\n  for (const segment of segments) {\n    if (!segment) continue;\n\n    if (isRouteSegmentDynamic(segment.dynamic)) {\n      config.dynamicConfig = segment.dynamic;\n    }\n\n    if (segment.dynamicParams === false) {\n      config.dynamicParamsConfig = false;\n    } else if (segment.dynamicParams === true && config.dynamicParamsConfig !== false) {\n      config.dynamicParamsConfig = true;\n    }\n\n    if (isRouteSegmentFetchCache(segment.fetchCache)) {\n      const fetchCache = segment.fetchCache;\n\n      if (hasParentDefaultNoStore && (fetchCache === \"auto\" || isCacheFetchCacheMode(fetchCache))) {\n        throw new Error(describeFetchCacheConflict(fetchCache));\n      }\n\n      if (fetchCache === \"force-cache\") hasForceCache = true;\n      if (fetchCache === \"force-no-store\") hasForceNoStore = true;\n      if (fetchCache === \"only-cache\") hasOnlyCache = true;\n      if (fetchCache === \"only-no-store\") hasOnlyNoStore = true;\n\n      const hasCacheEnforcer = hasForceCache || hasOnlyCache;\n      const hasNoStoreEnforcer = hasForceNoStore || hasOnlyNoStore;\n      if (hasCacheEnforcer && hasNoStoreEnforcer) {\n        throw new Error(describeFetchCacheConflict(fetchCache));\n      }\n\n      if (fetchCache === \"default-no-store\") {\n        hasParentDefaultNoStore = true;\n      }\n\n      if (hasForceCache) {\n        config.fetchCache = \"force-cache\";\n      } else if (hasForceNoStore) {\n        config.fetchCache = \"force-no-store\";\n      } else if (hasOnlyCache) {\n        config.fetchCache = \"only-cache\";\n      } else if (hasOnlyNoStore) {\n        config.fetchCache = \"only-no-store\";\n      } else {\n        config.fetchCache = fetchCache;\n      }\n    }\n\n    config.revalidateSeconds = resolveRevalidateSeconds(\n      config.revalidateSeconds,\n      segment.revalidate,\n    );\n  }\n\n  if (config.dynamicConfig === \"force-dynamic\") {\n    config.revalidateSeconds = 0;\n  }\n\n  // Top-level dynamic modes supply fetchCache defaults unless a segment does.\n  if (config.fetchCache === undefined) {\n    if (config.dynamicConfig === \"force-dynamic\") {\n      config.fetchCache = \"force-no-store\";\n    } else if (config.dynamicConfig === \"error\") {\n      config.fetchCache = \"only-cache\";\n    }\n  }\n\n  // Static-only dynamic modes change the default, but explicit dynamicParams wins.\n  if (\n    config.dynamicParamsConfig === undefined &&\n    (config.dynamicConfig === \"error\" || config.dynamicConfig === \"force-static\")\n  ) {\n    config.dynamicParamsConfig = false;\n  }\n\n  return config;\n}\n\nexport function resolveAppPageFetchCacheMode(\n  options: ResolveAppPageSegmentConfigOptions,\n): FetchCacheMode | null {\n  return resolveAppPageSegmentConfig(options).fetchCache ?? null;\n}\n"],"mappings":";AAuBA,MAAM,iBAAiB,IAAI,IAAa;CAAC;CAAQ;CAAS;CAAiB;CAAe,CAAC;AAC3F,MAAM,qBAAqB,IAAI,IAAa;CAC1C;CACA;CACA;CACA;CACA;CACA;CACA;CACD,CAAC;AAEF,SAAS,sBAAsB,OAAiD;AAC9E,QAAO,eAAe,IAAI,MAAM;;AAGlC,SAAS,yBAAyB,OAAyC;AACzE,QAAO,mBAAmB,IAAI,MAAM;;AAGtC,SAAS,yBAAyB,SAAwB,OAA+B;AAIvF,KAAI,OAAO,UAAU,SACnB,QAAO;AAGT,KAAI,YAAY,KACd,QAAO;AAGT,QAAO,QAAQ,UAAU,QAAQ;;AAGnC,SAAS,sBAAsB,OAAgC;AAC7D,QAAO,UAAU,mBAAmB,UAAU,iBAAiB,UAAU;;AAG3E,SAAS,2BAA2B,OAA+B;AACjE,QAAO,sEAAsE,MAAM;;;;;;;;;;AAWrF,SAAgB,4BACd,SAC+B;CAC/B,MAAM,WAAW,CAAC,GAAI,QAAQ,WAAW,EAAE,EAAG,QAAQ,KAAK;CAM3D,MAAM,SAAwC,EAC5C,mBAAmB,MACpB;CACD,IAAI,gBAAgB;CACpB,IAAI,kBAAkB;CACtB,IAAI,eAAe;CACnB,IAAI,iBAAiB;CACrB,IAAI,0BAA0B;AAE9B,MAAK,MAAM,WAAW,UAAU;AAC9B,MAAI,CAAC,QAAS;AAEd,MAAI,sBAAsB,QAAQ,QAAQ,CACxC,QAAO,gBAAgB,QAAQ;AAGjC,MAAI,QAAQ,kBAAkB,MAC5B,QAAO,sBAAsB;WACpB,QAAQ,kBAAkB,QAAQ,OAAO,wBAAwB,MAC1E,QAAO,sBAAsB;AAG/B,MAAI,yBAAyB,QAAQ,WAAW,EAAE;GAChD,MAAM,aAAa,QAAQ;AAE3B,OAAI,4BAA4B,eAAe,UAAU,sBAAsB,WAAW,EACxF,OAAM,IAAI,MAAM,2BAA2B,WAAW,CAAC;AAGzD,OAAI,eAAe,cAAe,iBAAgB;AAClD,OAAI,eAAe,iBAAkB,mBAAkB;AACvD,OAAI,eAAe,aAAc,gBAAe;AAChD,OAAI,eAAe,gBAAiB,kBAAiB;AAIrD,QAFyB,iBAAiB,kBACf,mBAAmB,gBAE5C,OAAM,IAAI,MAAM,2BAA2B,WAAW,CAAC;AAGzD,OAAI,eAAe,mBACjB,2BAA0B;AAG5B,OAAI,cACF,QAAO,aAAa;YACX,gBACT,QAAO,aAAa;YACX,aACT,QAAO,aAAa;YACX,eACT,QAAO,aAAa;OAEpB,QAAO,aAAa;;AAIxB,SAAO,oBAAoB,yBACzB,OAAO,mBACP,QAAQ,WACT;;AAGH,KAAI,OAAO,kBAAkB,gBAC3B,QAAO,oBAAoB;AAI7B,KAAI,OAAO,eAAe,KAAA;MACpB,OAAO,kBAAkB,gBAC3B,QAAO,aAAa;WACX,OAAO,kBAAkB,QAClC,QAAO,aAAa;;AAKxB,KACE,OAAO,wBAAwB,KAAA,MAC9B,OAAO,kBAAkB,WAAW,OAAO,kBAAkB,gBAE9D,QAAO,sBAAsB;AAG/B,QAAO;;AAGT,SAAgB,6BACd,SACuB;AACvB,QAAO,4BAA4B,QAAQ,CAAC,cAAc"}

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

@@ -1,6 +1,8 @@
+import { FetchCacheMode } from "../shims/fetch-cache.js";
 import { HeadersAccessPhase } from "../shims/headers.js";
 
 //#region src/server/app-server-action-execution.d.ts
+type AppPageParams = Record<string, string | string[]>;
 type AppServerActionErrorReporter = (error: Error, request: {
   path: string;
   method: string;
@@ -12,6 +14,48 @@ type AppServerActionErrorReporter = (error: Error, request: {
 }) => void;
 type AppServerActionDecoder = (body: FormData) => Promise<unknown>;
 type ReadFormDataWithLimit = (request: Request, maxBytes: number) => Promise<FormData>;
+type ReadBodyWithLimit = (request: Request, maxBytes: number) => Promise<string>;
+type AppServerActionReturnValue = {
+  data: unknown;
+  ok: true;
+} | {
+  data: unknown;
+  ok: false;
+};
+type AppServerActionRoute = {
+  pattern: string;
+};
+type AppServerActionMatch<TRoute extends AppServerActionRoute> = {
+  params: AppPageParams;
+  route: TRoute;
+};
+type AppServerActionIntercept<TPage = unknown> = {
+  matchedParams: AppPageParams;
+  page: TPage;
+  slotKey: string;
+  sourceRouteIndex: number;
+};
+type BuildServerActionPageElementOptions<TRoute extends AppServerActionRoute, TInterceptOpts> = {
+  cleanPathname: string;
+  interceptOpts: TInterceptOpts | undefined;
+  isRscRequest: boolean;
+  mountedSlotsHeader: string | null;
+  params: AppPageParams;
+  request: Request;
+  route: TRoute;
+  searchParams: URLSearchParams;
+};
+type AppServerActionRscModel<TElement> = {
+  returnValue: AppServerActionReturnValue;
+  root: TElement;
+};
+type RenderServerActionRscStreamOptions<TTemporaryReferences> = {
+  onError: (error: unknown) => unknown;
+  temporaryReferences: TTemporaryReferences;
+};
+type DecodeServerActionReplyOptions<TTemporaryReferences> = {
+  temporaryReferences: TTemporaryReferences;
+};
 type HandleProgressiveServerActionRequestOptions = {
   actionId: string | null;
   allowedOrigins: string[];
@@ -28,8 +72,51 @@ type HandleProgressiveServerActionRequestOptions = {
   request: Request;
   setHeadersAccessPhase: (phase: HeadersAccessPhase) => HeadersAccessPhase;
 };
+type HandleServerActionRscRequestOptions<TElement, TRoute extends AppServerActionRoute, TInterceptOpts, TTemporaryReferences, TPage = unknown> = {
+  actionId: string | null;
+  allowedOrigins: string[];
+  buildPageElement: (options: BuildServerActionPageElementOptions<TRoute, TInterceptOpts>) => TElement;
+  cleanPathname: string;
+  clearRequestContext: () => void;
+  contentType: string;
+  createNotFoundElement: (routeId: string) => TElement;
+  createPayloadRouteId: (pathname: string, interceptionContext: string | null) => string;
+  createRscOnErrorHandler: (request: Request, pathname: string, pattern: string) => (error: unknown) => unknown;
+  createTemporaryReferenceSet: () => TTemporaryReferences;
+  decodeReply: (body: string | FormData, options: DecodeServerActionReplyOptions<TTemporaryReferences>) => Promise<unknown[]> | unknown[];
+  findIntercept: (pathname: string) => AppServerActionIntercept<TPage> | null;
+  getAndClearPendingCookies: () => string[];
+  getDraftModeCookieHeader: () => string | null | undefined;
+  getRouteParamNames: (route: TRoute) => readonly string[];
+  getSourceRoute: (sourceRouteIndex: number) => TRoute | undefined;
+  isRscRequest: boolean;
+  loadServerAction: (actionId: string) => Promise<unknown>;
+  matchRoute: (pathname: string) => AppServerActionMatch<TRoute> | null;
+  maxActionBodySize: number;
+  middlewareHeaders: Headers | null;
+  middlewareStatus: number | null | undefined;
+  mountedSlotsHeader: string | null;
+  readBodyWithLimit: ReadBodyWithLimit;
+  readFormDataWithLimit: ReadFormDataWithLimit;
+  renderToReadableStream: (model: AppServerActionRscModel<TElement>, options: RenderServerActionRscStreamOptions<TTemporaryReferences>) => BodyInit | null | Promise<BodyInit | null>;
+  reportRequestError: AppServerActionErrorReporter;
+  resolveRouteFetchCacheMode?: (route: TRoute) => FetchCacheMode | null;
+  request: Request;
+  sanitizeErrorForClient: (error: unknown) => unknown;
+  searchParams: URLSearchParams;
+  setHeadersAccessPhase: (phase: HeadersAccessPhase) => HeadersAccessPhase;
+  setNavigationContext: (context: {
+    params: AppPageParams;
+    pathname: string;
+    searchParams: URLSearchParams;
+  }) => void;
+  toInterceptOpts: (intercept: AppServerActionIntercept<TPage>) => TInterceptOpts;
+};
+declare function readActionBodyWithLimit(request: Request, maxBytes: number): Promise<string>;
+declare function readActionFormDataWithLimit(request: Request, maxBytes: number): Promise<FormData>;
 declare function isProgressiveServerActionRequest(request: Pick<Request, "method">, contentType: string, actionId: string | null): boolean;
 declare function handleProgressiveServerActionRequest(options: HandleProgressiveServerActionRequestOptions): Promise<Response | 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, handleProgressiveServerActionRequest, isProgressiveServerActionRequest };
+export { HandleProgressiveServerActionRequestOptions, HandleServerActionRscRequestOptions, handleProgressiveServerActionRequest, handleServerActionRscRequest, isProgressiveServerActionRequest, readActionBodyWithLimit, readActionFormDataWithLimit };
 //# sourceMappingURL=app-server-action-execution.d.ts.map