@qzsy/vinext 0.1.7

package/dist/server/app-rsc-request-normalization.js

@@ -0,0 +1,75 @@
+import { normalizePathnameForRouteMatchStrict } from "../routing/utils.js";
+import { hasBasePath, stripBasePath } from "../utils/base-path.js";
+import { VINEXT_CLIENT_REUSE_MANIFEST_HEADER, VINEXT_INTERCEPTION_CONTEXT_HEADER, VINEXT_MOUNTED_SLOTS_HEADER, VINEXT_RSC_RENDER_MODE_HEADER } from "./headers.js";
+import { normalizePath } from "./normalize-path.js";
+import { badRequestResponse, notFoundResponse } from "./http-error-responses.js";
+import { guardProtocolRelativeUrl } from "./request-pipeline.js";
+import { normalizeMountedSlotsHeader } from "./app-mounted-slots-header.js";
+import { APP_RSC_RENDER_MODE_NAVIGATION, parseAppRscRenderMode } from "./app-rsc-render-mode.js";
+import { stripRscSuffix } from "./app-rsc-cache-busting.js";
+import { parseClientReuseManifestHeader } from "./client-reuse-manifest.js";
+import { normalizeInterceptionContextHeader } from "./app-interception-context-header.js";
+//#region src/server/app-rsc-request-normalization.ts
+/**
+* Normalize an App Router RSC request.
+*
+* Performs all security-sensitive and compatibility-sensitive preprocessing before
+* route matching. The ordering of steps is security-critical — changing it introduces
+* vulnerabilities:
+*
+*   1. Parse URL
+*   2. Protocol-relative URL guard — on the raw pathname, BEFORE normalizePath collapses
+*      `//` to `/`. If the guard ran after normalization, `//evil.com` → `/evil.com`
+*      would bypass the check and reach the trailing-slash redirector, which echoes the
+*      path into a `Location` header that browsers interpret as protocol-relative.
+*   3. Strict percent-decode each segment — throws on malformed sequences (→ 400). Must
+*      run before basePath check so %2F-encoded slashes cannot create fake basePath prefixes.
+*   4. Collapse double-slashes, resolve `.` and `..` segments (normalizePath)
+*   5. basePath check + strip — 404 when pathname lacks the basePath prefix.
+*      `/__vinext/` bypasses this for internal prerender endpoints.
+*   6. RSC detection: `.rsc` suffix, or Next-style `RSC: 1` plus the internal
+*      `_rsc` cache-busting query. The header alone does not select payload
+*      rendering at the canonical HTML URL, so caches that ignore Vary cannot
+*      store Flight responses under HTML URLs.
+*   7. cleanPathname — pathname with `.rsc` suffix stripped
+*   8. Sanitize X-Vinext-Interception-Context — strip null bytes (header injection)
+*   9. Normalize x-vinext-mounted-slots — dedup and sort for canonical cache keys
+*   10. Read semantic render mode for refresh/action payload rendering
+*   11. Parse ClientReuseManifest hints on canonical RSC payload requests
+*
+* @returns A 400 or 404 Response for invalid or out-of-scope inputs,
+*          or a NormalizedRscRequest for valid requests.
+*/
+function normalizeRscRequest(request, basePath) {
+	const url = new URL(request.url);
+	const protoGuard = guardProtocolRelativeUrl(url.pathname);
+	if (protoGuard) return protoGuard;
+	let decoded;
+	try {
+		decoded = normalizePathnameForRouteMatchStrict(url.pathname);
+	} catch {
+		return badRequestResponse();
+	}
+	let pathname = normalizePath(decoded);
+	if (basePath) {
+		if (!hasBasePath(pathname, basePath) && !pathname.startsWith("/__vinext/")) return notFoundResponse();
+		pathname = stripBasePath(pathname, basePath);
+	}
+	const isRscRequest = pathname.endsWith(".rsc") || request.headers.get("RSC") === "1" && url.searchParams.has("_rsc");
+	const cleanPathname = stripRscSuffix(pathname);
+	const interceptionContextHeader = normalizeInterceptionContextHeader(request.headers.get(VINEXT_INTERCEPTION_CONTEXT_HEADER));
+	const mountedSlotsHeader = normalizeMountedSlotsHeader(request.headers.get(VINEXT_MOUNTED_SLOTS_HEADER));
+	const renderMode = isRscRequest ? parseAppRscRenderMode(request.headers.get(VINEXT_RSC_RENDER_MODE_HEADER)) : APP_RSC_RENDER_MODE_NAVIGATION;
+	return {
+		clientReuseManifest: isRscRequest ? parseClientReuseManifestHeader(request.headers.get(VINEXT_CLIENT_REUSE_MANIFEST_HEADER)) : { kind: "absent" },
+		url,
+		pathname,
+		cleanPathname,
+		isRscRequest,
+		interceptionContextHeader,
+		mountedSlotsHeader,
+		renderMode
+	};
+}
+//#endregion
+export { normalizeMountedSlotsHeader, normalizeRscRequest };

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

@@ -0,0 +1,37 @@
+import { NextHeader, NextI18nConfig } 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[];
+  /**
+   * i18n config used to splice the default locale into unprefixed paths
+   * before config header matching, so locale-aware `has`/`missing` rules
+   * with `:locale` placeholders or `locale: false` overrides still match
+   * default-locale URLs (issue #1336, item 4).
+   */
+  i18nConfig: NextI18nConfig | null;
+  /**
+   * 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 App Router response finalization that must happen outside individual
+ * route dispatchers.
+ *
+ * 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 };

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

@@ -0,0 +1,54 @@
+import { normalizePathnameForRouteMatch } from "../routing/utils.js";
+import { hasBasePath, stripBasePath } from "../utils/base-path.js";
+import "./headers.js";
+import { normalizePath } from "./normalize-path.js";
+import { applyConfigHeadersToResponse } from "./request-pipeline.js";
+import { applyCdnResponseHeaders } from "./cache-control.js";
+import { normalizeDefaultLocalePathname } from "./pages-i18n.js";
+import { VINEXT_RSC_VARY_HEADER } from "./app-rsc-cache-busting.js";
+import { mergeVaryHeader } from "./middleware-response-headers.js";
+//#region src/server/app-rsc-response-finalizer.ts
+/**
+* Apply App Router response finalization that must happen outside individual
+* route dispatchers.
+*
+* 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 (!response.headers.has("x-vinext-static-file")) {
+		const varyHeader = response.headers.get("Vary");
+		if (varyHeader === null) response.headers.set("Vary", VINEXT_RSC_VARY_HEADER);
+		else if (varyHeader !== VINEXT_RSC_VARY_HEADER) mergeVaryHeader(response.headers, VINEXT_RSC_VARY_HEADER);
+	}
+	if (!response.headers.has("Cache-Control")) applyCdnResponseHeaders(response.headers, { cacheControl: "" });
+	if (!options.configHeaders.length) return response;
+	const url = new URL(request.url);
+	let pathname;
+	try {
+		pathname = normalizePath(normalizePathnameForRouteMatch(url.pathname));
+	} catch {
+		pathname = url.pathname;
+	}
+	const hadBasePath = !options.basePath || hasBasePath(pathname, options.basePath);
+	pathname = stripBasePath(pathname, options.basePath);
+	const matchPathname = options.i18nConfig ? normalizeDefaultLocalePathname(pathname, options.i18nConfig, { hostname: url.hostname }) : pathname;
+	applyConfigHeadersToResponse(response.headers, {
+		configHeaders: options.configHeaders,
+		pathname: matchPathname,
+		requestContext: options.requestContext,
+		basePathState: {
+			basePath: options.basePath,
+			hadBasePath
+		}
+	});
+	return response;
+}
+//#endregion
+export { finalizeAppRscResponse };

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

@@ -0,0 +1,93 @@
+import { RoutePatternParams } from "../routing/route-pattern.js";
+
+//#region src/server/app-rsc-route-matching.d.ts
+/**
+ * Sentinel slot key used for sibling-style interception entries.
+ * When a matched intercept carries this key, the render layer replaces the
+ * route's main page element instead of a parallel slot.
+ */
+declare const SIBLING_PAGE_INTERCEPT_SLOT_KEY = "__vinext_page_intercept";
+type AppRscRouteParams = RoutePatternParams;
+type AppRscInterceptForMatching = {
+  targetPattern: string;
+  /**
+   * URL pattern of the *intercepting route* (the path that owns the slot,
+   * with route groups and `@slot` segments stripped). Mirrors Next.js'
+   * `interceptingRoute` from `extractInterceptionRouteInformation`.
+   *
+   * Next.js implements interception as a rewrite that fires only when the
+   * `Next-URL` header matches `^<sourceMatchPattern>(?:/.*)?$`. vinext's
+   * matcher enforces the same constraint at `findIntercept`: an intercept
+   * whose `targetPattern` matches the request URL is only valid when the
+   * provided source pathname (X-Vinext-Interception-Context / Next-URL)
+   * matches this pattern, with descendants allowed.
+   *
+   * Optional for backwards compat: when absent or empty, the matcher falls
+   * back to the legacy behavior of matching by target alone (still gated on
+   * a non-null source pathname).
+   *
+   * @see https://github.com/vercel/next.js/blob/canary/packages/next/src/lib/generate-interception-routes-rewrites.ts
+   */
+  sourceMatchPattern?: string;
+  sourcePageSegments?: readonly string[];
+  interceptLayouts: readonly unknown[];
+  __loadInterceptLayouts?: readonly (() => Promise<unknown>)[] | null;
+  page: unknown;
+  __pageLoader?: (() => Promise<unknown>) | null;
+  params: readonly string[];
+};
+type AppRscSlotForMatching = {
+  id?: string | null;
+  intercepts?: readonly AppRscInterceptForMatching[];
+};
+type AppRscSiblingInterceptForMatching = {
+  targetPattern: string;
+  sourceMatchPattern: string | null;
+  sourcePageSegments?: readonly string[];
+  slotId: string | null;
+  interceptLayouts: readonly unknown[];
+  __loadInterceptLayouts?: readonly (() => Promise<unknown>)[] | null;
+  page: unknown;
+  __pageLoader?: (() => Promise<unknown>) | null;
+  params: readonly string[];
+};
+type AppRscRouteForMatching = {
+  pattern: string;
+  patternParts: string[];
+  slots?: Record<string, AppRscSlotForMatching>;
+  siblingIntercepts?: AppRscSiblingInterceptForMatching[];
+};
+type AppRscInterceptMatch = AppRscInterceptLookupEntry & {
+  matchedParams: AppRscRouteParams;
+};
+type AppRscInterceptLoadState = {
+  page: unknown;
+  pageLoading: Promise<unknown> | null;
+  interceptLayoutsLoading: Promise<readonly unknown[]> | null;
+};
+type AppRscInterceptLookupEntry = {
+  sourceRouteIndex: number;
+  slotKey: string;
+  targetPattern: string;
+  targetPatternParts: string[];
+  sourceMatchPattern: string | null;
+  sourceMatchPatternParts: string[] | null;
+  sourcePageSegments: readonly string[] | null;
+  interceptLayouts: readonly unknown[];
+  __loadInterceptLayouts?: readonly (() => Promise<unknown>)[] | null;
+  page: unknown;
+  __pageLoader?: (() => Promise<unknown>) | null;
+  __loadState: AppRscInterceptLoadState;
+  params: readonly string[];
+  slotId: string | null;
+};
+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 { SIBLING_PAGE_INTERCEPT_SLOT_KEY, createAppRscRouteMatcher, matchAppRscRoutePattern };

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

@@ -0,0 +1,134 @@
+import { splitPathnameForRouteMatch } from "../routing/utils.js";
+import { buildRouteTrie, trieMatch } from "../routing/route-trie.js";
+import { matchRoutePattern, matchRoutePatternPrefix } from "../routing/route-pattern.js";
+//#region src/server/app-rsc-route-matching.ts
+/**
+* Sentinel slot key used for sibling-style interception entries.
+* When a matched intercept carries this key, the render layer replaces the
+* route's main page element instead of a parallel slot.
+*/
+const SIBLING_PAGE_INTERCEPT_SLOT_KEY = "__vinext_page_intercept";
+function createRouteParams() {
+	return Object.create(null);
+}
+function appRscPathnameParts(pathname) {
+	const pathOnly = pathname.split("?")[0];
+	return splitPathnameForRouteMatch(pathOnly === "/" ? "/" : pathOnly.replace(/\/$/, ""));
+}
+function createAppRscRouteMatcher(routes) {
+	const routeTrie = buildRouteTrie(routes);
+	const interceptLookup = createInterceptLookup(routes);
+	const routeIndexes = new Map(routes.map((route, index) => [route, index]));
+	return {
+		matchRoute(url) {
+			return trieMatch(routeTrie, appRscPathnameParts(url));
+		},
+		findIntercept(pathname, sourcePathname = null) {
+			if (sourcePathname === null) return null;
+			const urlParts = appRscPathnameParts(pathname);
+			const sourceParts = appRscPathnameParts(sourcePathname);
+			const matchedSourceRoute = trieMatch(routeTrie, sourceParts);
+			for (const entry of interceptLookup) {
+				if (!matchInterceptSource(sourceParts, entry)) continue;
+				const params = matchAppRscRoutePattern(urlParts, entry.targetPatternParts);
+				if (params === null) continue;
+				const concreteSourceRouteIndex = matchedSourceRoute && entry.sourceMatchPatternParts !== null ? routeIndexes.get(matchedSourceRoute.route) ?? entry.sourceRouteIndex : entry.sourceRouteIndex;
+				const sourceRoute = routes[concreteSourceRouteIndex];
+				const matchedSourceParams = matchedSourceRoute && entry.sourceMatchPatternParts !== null ? matchedSourceRoute.params : sourceRoute ? matchAppRscRoutePattern(sourceParts, sourceRoute.patternParts) : null;
+				if (matchedSourceParams === null && entry.sourceMatchPatternParts === null) continue;
+				const sourceParams = matchedSourceParams ?? createRouteParams();
+				return {
+					...entry,
+					page: entry.__loadState.page,
+					sourceRouteIndex: concreteSourceRouteIndex,
+					matchedParams: mergeMatchedParams(sourceParams, params)
+				};
+			}
+			return null;
+		}
+	};
+}
+/**
+* Check whether the request's source pathname (Next-URL / interception
+* context) satisfies the intercept entry's intercepting-route pattern, with
+* descendants allowed. Mirrors the header regex shape Next.js emits for the
+* generated interception rewrite: `^<pattern>(?:/.*)?$`.
+*
+* When the entry has no declared `sourceMatchPatternParts`, fall back to the
+* legacy behavior of accepting any source (we still require the source to be
+* non-null at the caller — see `findIntercept`).
+*/
+function matchInterceptSource(sourceParts, entry) {
+	const patternParts = entry.sourceMatchPatternParts;
+	if (!patternParts) return true;
+	if (patternParts.length === 0) return true;
+	return matchRoutePatternPrefix(sourceParts, patternParts);
+}
+function createInterceptLookup(routes) {
+	const patternToIndex = new Map(routes.map((r, i) => [r.pattern, i]));
+	const interceptLookup = [];
+	for (let routeIndex = 0; routeIndex < routes.length; routeIndex++) {
+		const route = routes[routeIndex];
+		if (route.slots) for (const [slotKey, slotModule] of Object.entries(route.slots)) {
+			if (!slotModule.intercepts) continue;
+			for (const intercept of slotModule.intercepts) {
+				const sourceMatchPattern = intercept.sourceMatchPattern ?? null;
+				const sourceMatchPatternParts = sourceMatchPattern ? sourceMatchPattern.split("/").filter(Boolean) : null;
+				const ownerRouteIndex = sourceMatchPattern !== null ? patternToIndex.get(sourceMatchPattern) ?? routeIndex : routeIndex;
+				interceptLookup.push({
+					sourceRouteIndex: ownerRouteIndex,
+					slotKey,
+					slotId: typeof slotModule.id === "string" ? slotModule.id : null,
+					targetPattern: intercept.targetPattern,
+					targetPatternParts: intercept.targetPattern.split("/").filter(Boolean),
+					sourceMatchPattern,
+					sourceMatchPatternParts,
+					sourcePageSegments: intercept.sourcePageSegments ?? null,
+					interceptLayouts: intercept.interceptLayouts,
+					__loadInterceptLayouts: intercept.__loadInterceptLayouts,
+					page: intercept.page,
+					__pageLoader: intercept.__pageLoader,
+					__loadState: {
+						page: intercept.page,
+						pageLoading: null,
+						interceptLayoutsLoading: null
+					},
+					params: intercept.params
+				});
+			}
+		}
+		if (route.siblingIntercepts) for (const intercept of route.siblingIntercepts) {
+			const sourceMatchPattern = intercept.sourceMatchPattern ?? null;
+			const sourceMatchPatternParts = sourceMatchPattern ? sourceMatchPattern.split("/").filter(Boolean) : null;
+			interceptLookup.push({
+				sourceRouteIndex: routeIndex,
+				slotKey: SIBLING_PAGE_INTERCEPT_SLOT_KEY,
+				slotId: typeof intercept.slotId === "string" ? intercept.slotId : null,
+				targetPattern: intercept.targetPattern,
+				targetPatternParts: intercept.targetPattern.split("/").filter(Boolean),
+				sourceMatchPattern,
+				sourceMatchPatternParts,
+				sourcePageSegments: intercept.sourcePageSegments ?? null,
+				interceptLayouts: intercept.interceptLayouts,
+				__loadInterceptLayouts: intercept.__loadInterceptLayouts,
+				page: intercept.page,
+				__pageLoader: intercept.__pageLoader,
+				__loadState: {
+					page: intercept.page,
+					pageLoading: null,
+					interceptLayoutsLoading: null
+				},
+				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 { SIBLING_PAGE_INTERCEPT_SLOT_KEY, createAppRscRouteMatcher, matchAppRscRoutePattern };

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

@@ -0,0 +1,46 @@
+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;
+  runtime?: unknown;
+  unstable_dynamicStaleTime?: unknown;
+};
+type EffectiveAppPageSegmentConfig = {
+  dynamicConfig?: AppRouteSegmentDynamic;
+  dynamicParamsConfig?: boolean;
+  dynamicStaleTimeSeconds?: number;
+  fetchCache?: FetchCacheMode;
+  revalidateSeconds: number | null;
+  runtime?: "edge" | "experimental-edge" | "nodejs";
+};
+type ResolveAppPageSegmentConfigOptions = {
+  layouts?: readonly (AppRouteSegmentConfigModule | null | undefined)[];
+  page?: AppRouteSegmentConfigModule | null;
+  parallelPages?: readonly (AppRouteSegmentConfigModule | null | undefined)[];
+};
+/**
+ * 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;
+/**
+ * Resolve the `fetchCache` segment config exported by a route handler module.
+ *
+ * Route handlers have no layout chain, so the module's own export applies
+ * 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 };

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

@@ -0,0 +1,113 @@
+import { isEdgeApiRuntime } from "./edge-api-runtime.js";
+//#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 isRouteSegmentRuntime(value) {
+	return value === "edge" || value === "experimental-edge" || value === "nodejs";
+}
+function resolveRevalidateSeconds(current, value) {
+	if (value === false) {
+		if (current === null) return Infinity;
+		return current === Infinity ? Infinity : current;
+	}
+	if (typeof value !== "number") return current;
+	if (current === null) return value;
+	return value < current ? value : current;
+}
+function resolveDynamicStaleTimeSeconds(current, value) {
+	if (typeof value !== "number" || !Number.isInteger(value) || value < 0) return current;
+	return current === void 0 ? value : Math.min(current, value);
+}
+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 (isRouteSegmentRuntime(segment.runtime)) config.runtime = segment.runtime;
+		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);
+	}
+	for (const segment of [options.page, ...options.parallelPages ?? []]) {
+		if (!segment) continue;
+		config.dynamicStaleTimeSeconds = resolveDynamicStaleTimeSeconds(config.dynamicStaleTimeSeconds, segment.unstable_dynamicStaleTime);
+	}
+	if (config.dynamicConfig === "force-dynamic") config.revalidateSeconds = 0;
+	if (config.fetchCache === void 0) {
+		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;
+}
+/**
+* Resolve the `fetchCache` segment config exported by a route handler module.
+*
+* Route handlers have no layout chain, so the module's own export applies
+* directly. Mirrors upstream's app-route module, which copies
+* `userland.fetchCache` into the work store before invoking the handler.
+*/
+function resolveAppRouteHandlerFetchCacheMode(handler) {
+	return isRouteSegmentFetchCache(handler.fetchCache) ? handler.fetchCache : null;
+}
+function isEdgeRuntime(runtime) {
+	return isEdgeApiRuntime(runtime);
+}
+//#endregion
+export { isEdgeRuntime, resolveAppPageFetchCacheMode, resolveAppPageSegmentConfig, resolveAppRouteHandlerFetchCacheMode };