@qzsy/vinext 0.1.7

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

@@ -0,0 +1,137 @@
+import { AppPageSpecialError } from "./app-page-execution.js";
+import { AppLayoutParamAccessTracker } from "./app-layout-param-observation.js";
+
+//#region src/server/app-page-request.d.ts
+type AppPageParams = Record<string, string | string[]>;
+type GenerateStaticParams = (args: {
+  params: AppPageParams;
+}) => unknown;
+type Awaitable<T> = T | Promise<T>;
+type GenerateStaticParamsModule = {
+  generateStaticParams?: GenerateStaticParams | null;
+};
+type GenerateStaticParamsSource = {
+  generateStaticParams: GenerateStaticParams;
+  parentParamNames: readonly string[];
+};
+type ValidateAppPageDynamicParamsOptions = {
+  clearRequestContext: () => void;
+  enforceStaticParamsOnly: boolean;
+  generateStaticParams?: GenerateStaticParams | GenerateStaticParamsSource | readonly (GenerateStaticParams | GenerateStaticParamsSource | null | undefined)[] | null;
+  isDynamicRoute: boolean;
+  params: AppPageParams;
+};
+type ResolveAppPageGenerateStaticParamsSourcesOptions = {
+  layouts?: readonly (GenerateStaticParamsModule | null | undefined)[];
+  layoutTreePositions?: readonly number[];
+  page?: GenerateStaticParamsModule | null;
+  routeSegments: readonly string[];
+};
+type BuildAppPageElementOptions<TElement> = {
+  buildPageElement: () => Promise<TElement>;
+  probePageSpecialError?: () => Promise<AppPageSpecialError | null>;
+  renderErrorBoundaryPage: (error: unknown) => Promise<Response | null>;
+  renderSpecialError: (specialError: AppPageSpecialError) => Promise<Response>;
+  resolveSpecialError: (error: unknown) => AppPageSpecialError | null;
+};
+type BuildAppPageElementResult<TElement> = {
+  element: TElement | null;
+  response: Response | null;
+};
+type AppPageInterceptMatch<TPage = unknown> = {
+  interceptLayouts?: readonly unknown[] | null;
+  __loadInterceptLayouts?: readonly (() => Promise<unknown>)[] | null;
+  matchedParams: AppPageParams;
+  page: TPage;
+  __pageLoader?: (() => Promise<TPage>) | null;
+  __loadState?: {
+    page: TPage;
+    pageLoading: Promise<TPage> | null;
+    interceptLayoutsLoading: Promise<readonly unknown[]> | null;
+  };
+  slotId?: string | null;
+  slotKey: string;
+  sourceRouteIndex: number;
+  sourcePageSegments?: readonly string[] | null;
+};
+type ResolveAppPageInterceptMatchOptions<TRoute, TPage, TInterceptOpts> = {
+  cleanPathname: string;
+  currentRoute: TRoute;
+  findIntercept: (pathname: string) => AppPageInterceptMatch<TPage> | null;
+  getRouteParamNames: (route: TRoute) => readonly string[];
+  getSourceRoute: (sourceRouteIndex: number) => Awaitable<TRoute | undefined>;
+  isRscRequest: boolean;
+  toInterceptOpts: (intercept: AppPageInterceptMatch<TPage>) => TInterceptOpts;
+};
+type ResolveAppPageInterceptMatchResult<TRoute, TInterceptOpts> = {
+  interceptOpts: TInterceptOpts;
+  matchedParams: AppPageParams;
+  sourceParams: AppPageParams;
+  sourceRoute: TRoute;
+};
+type ResolveAppPageInterceptionRerenderTargetOptions<TRoute, TPage, TInterceptOpts> = {
+  cleanPathname: string;
+  currentParams: AppPageParams;
+  currentRoute: TRoute;
+  findIntercept: (pathname: string) => AppPageInterceptMatch<TPage> | null;
+  getRouteParamNames: (route: TRoute) => readonly string[];
+  getSourceRoute: (sourceRouteIndex: number) => Awaitable<TRoute | undefined>;
+  isRscRequest: boolean;
+  toInterceptOpts: (intercept: AppPageInterceptMatch<TPage>) => TInterceptOpts;
+};
+type ResolveAppPageInterceptionRerenderTargetResult<TRoute, TInterceptOpts> = {
+  interceptOpts: TInterceptOpts | undefined;
+  navigationParams: AppPageParams;
+  params: AppPageParams;
+  route: TRoute;
+};
+type ResolveAppPageActionRerenderTargetOptions<TRoute, TPage, TInterceptOpts> = ResolveAppPageInterceptionRerenderTargetOptions<TRoute, TPage, TInterceptOpts>;
+type ResolveAppPageActionRerenderTargetResult<TRoute, TInterceptOpts> = ResolveAppPageInterceptionRerenderTargetResult<TRoute, TInterceptOpts>;
+type ResolveAppPageInterceptOptions<TRoute, TPage, TInterceptOpts, TElement> = {
+  buildPageElement: (route: TRoute, params: AppPageParams, interceptOpts: TInterceptOpts | undefined, searchParams: URLSearchParams, layoutParamAccess?: AppLayoutParamAccessTracker) => Promise<TElement>;
+  cleanPathname: string;
+  currentRoute: TRoute;
+  findIntercept: (pathname: string) => AppPageInterceptMatch<TPage> | null;
+  getRouteParamNames: (route: TRoute) => readonly string[];
+  getSourceRoute: (sourceRouteIndex: number) => Awaitable<TRoute | undefined>;
+  isRscRequest: boolean;
+  layoutParamAccess?: AppLayoutParamAccessTracker;
+  resolveNavigationParams: (route: TRoute, params: AppPageParams, pathname: string, interceptOpts: TInterceptOpts) => AppPageParams;
+  renderInterceptResponse: (route: TRoute, element: TElement) => Promise<Response> | Response;
+  searchParams: URLSearchParams;
+  setNavigationContext: (context: {
+    params: AppPageParams;
+    pathname: string;
+    searchParams: URLSearchParams;
+  }) => void;
+  toInterceptOpts: (intercept: AppPageInterceptMatch<TPage>) => TInterceptOpts;
+};
+type ResolveAppPageInterceptResult<TInterceptOpts> = {
+  interceptOpts: TInterceptOpts | undefined;
+  response: Response | null;
+};
+declare function resolveAppPageGenerateStaticParamsSources(options: ResolveAppPageGenerateStaticParamsSourcesOptions): GenerateStaticParamsSource[];
+declare function validateAppPageDynamicParams(options: ValidateAppPageDynamicParamsOptions): Promise<Response | null>;
+/**
+ * Pure: decides whether the incoming request should re-render an intercepted
+ * source-route tree, and if so returns the source route, the source-route's
+ * param slice, the full matched param set (the URL params the client sees),
+ * and an opaque `interceptOpts` bag for the caller's render pipeline.
+ *
+ * Returns `null` in three decision-fallthrough cases:
+ *   - non-RSC requests (server rendering the direct page for a full HTML load)
+ *   - no intercepting route matches the path
+ *   - the match's source route IS the current route (the same branch today
+ *     returns `interceptOpts` for the direct render)
+ *
+ * Shared by both the GET path (resolveAppPageIntercept, which layers on
+ * `setNavigationContext` + element build + Response wrap) and the server-action
+ * POST path (entries/app-rsc-entry.ts), which runs its own response pipeline.
+ */
+declare function resolveAppPageInterceptMatch<TRoute, TPage, TInterceptOpts>(options: ResolveAppPageInterceptMatchOptions<TRoute, TPage, TInterceptOpts>): Promise<ResolveAppPageInterceptMatchResult<TRoute, TInterceptOpts> | null>;
+declare function resolveAppPageInterceptionRerenderTarget<TRoute, TPage, TInterceptOpts>(options: ResolveAppPageInterceptionRerenderTargetOptions<TRoute, TPage, TInterceptOpts>): Promise<ResolveAppPageInterceptionRerenderTargetResult<TRoute, TInterceptOpts>>;
+declare function resolveAppPageActionRerenderTarget<TRoute, TPage, TInterceptOpts>(options: ResolveAppPageActionRerenderTargetOptions<TRoute, TPage, TInterceptOpts>): Promise<ResolveAppPageActionRerenderTargetResult<TRoute, TInterceptOpts>>;
+declare function resolveAppPageIntercept<TRoute, TPage, TInterceptOpts, TElement>(options: ResolveAppPageInterceptOptions<TRoute, TPage, TInterceptOpts, TElement>): Promise<ResolveAppPageInterceptResult<TInterceptOpts>>;
+declare function buildAppPageElement<TElement>(options: BuildAppPageElementOptions<TElement>): Promise<BuildAppPageElementResult<TElement>>;
+//#endregion
+export { ValidateAppPageDynamicParamsOptions, buildAppPageElement, resolveAppPageActionRerenderTarget, resolveAppPageGenerateStaticParamsSources, resolveAppPageIntercept, resolveAppPageInterceptMatch, resolveAppPageInterceptionRerenderTarget, validateAppPageDynamicParams };

package/dist/server/app-page-request.js

@@ -0,0 +1,216 @@
+import { notFoundResponse } from "./http-error-responses.js";
+import { runWithFetchDedupe } from "../shims/fetch-cache.js";
+import { getAppPageSegmentParamName } from "./app-page-params.js";
+import { loadAppInterceptLayouts } from "./app-route-module-loader.js";
+//#region src/server/app-page-request.ts
+function pickRouteParams(matchedParams, routeParamNames) {
+	const params = {};
+	for (const paramName of routeParamNames) {
+		const value = matchedParams[paramName];
+		if (value !== void 0) params[paramName] = value;
+	}
+	return params;
+}
+function collectParentParamNames(routeSegments, boundaryPosition) {
+	const limit = Math.max(0, Math.min(boundaryPosition, routeSegments.length));
+	const names = [];
+	for (const segment of routeSegments.slice(0, limit)) {
+		const name = getAppPageSegmentParamName(segment);
+		if (name && !names.includes(name)) names.push(name);
+	}
+	return names;
+}
+function getLayoutGenerateStaticParamsBoundary(layoutTreePosition) {
+	return (layoutTreePosition ?? 0) - 1;
+}
+function resolveAppPageGenerateStaticParamsSources(options) {
+	const sources = [];
+	options.layouts?.forEach((layout, index) => {
+		if (typeof layout?.generateStaticParams !== "function") return;
+		sources.push({
+			generateStaticParams: layout.generateStaticParams,
+			parentParamNames: collectParentParamNames(options.routeSegments, getLayoutGenerateStaticParamsBoundary(options.layoutTreePositions?.[index]))
+		});
+	});
+	if (typeof options.page?.generateStaticParams === "function") sources.push({
+		generateStaticParams: options.page.generateStaticParams,
+		parentParamNames: collectParentParamNames(options.routeSegments, Math.max(0, options.routeSegments.length - 1))
+	});
+	return sources;
+}
+function areStaticParamsAllowed(params, staticParams) {
+	const paramKeys = Object.keys(params);
+	return staticParams.some((staticParamSet) => paramKeys.every((key) => {
+		const value = params[key];
+		const staticValue = staticParamSet[key];
+		if (staticValue === void 0) return true;
+		if (Array.isArray(value)) return JSON.stringify(value) === JSON.stringify(staticValue);
+		if (typeof staticValue === "string" || typeof staticValue === "number" || typeof staticValue === "boolean") return String(value) === String(staticValue);
+		return JSON.stringify(value) === JSON.stringify(staticValue);
+	}));
+}
+function normalizeGenerateStaticParams(generateStaticParams) {
+	return (Array.isArray(generateStaticParams) ? generateStaticParams : [generateStaticParams]).flatMap((source) => {
+		if (typeof source === "function") return [{
+			generateStaticParams: source,
+			parentParamNames: []
+		}];
+		if (typeof source?.generateStaticParams === "function") return [source];
+		return [];
+	});
+}
+async function validateAppPageDynamicParams(options) {
+	if (!options.enforceStaticParamsOnly || !options.isDynamicRoute) return null;
+	const generateStaticParamsSources = normalizeGenerateStaticParams(options.generateStaticParams);
+	if (generateStaticParamsSources.length === 0) {
+		options.clearRequestContext();
+		return notFoundResponse();
+	}
+	for (const source of generateStaticParamsSources) {
+		const staticParams = await runWithFetchDedupe(() => source.generateStaticParams({ params: pickRouteParams(options.params, source.parentParamNames) }));
+		if (Array.isArray(staticParams) && !areStaticParamsAllowed(options.params, staticParams)) {
+			options.clearRequestContext();
+			return notFoundResponse();
+		}
+	}
+	return null;
+}
+/**
+* Pure: decides whether the incoming request should re-render an intercepted
+* source-route tree, and if so returns the source route, the source-route's
+* param slice, the full matched param set (the URL params the client sees),
+* and an opaque `interceptOpts` bag for the caller's render pipeline.
+*
+* Returns `null` in three decision-fallthrough cases:
+*   - non-RSC requests (server rendering the direct page for a full HTML load)
+*   - no intercepting route matches the path
+*   - the match's source route IS the current route (the same branch today
+*     returns `interceptOpts` for the direct render)
+*
+* Shared by both the GET path (resolveAppPageIntercept, which layers on
+* `setNavigationContext` + element build + Response wrap) and the server-action
+* POST path (entries/app-rsc-entry.ts), which runs its own response pipeline.
+*/
+async function resolveAppPageInterceptMatch(options) {
+	const interceptState = await resolveAppPageInterceptState(options);
+	if (interceptState.kind !== "source-route") return null;
+	return {
+		interceptOpts: options.toInterceptOpts(interceptState.intercept),
+		matchedParams: interceptState.intercept.matchedParams,
+		sourceParams: pickRouteParams(interceptState.intercept.matchedParams, options.getRouteParamNames(interceptState.sourceRoute)),
+		sourceRoute: interceptState.sourceRoute
+	};
+}
+async function resolveAppPageInterceptState(options) {
+	if (!options.isRscRequest) return { kind: "none" };
+	const intercept = options.findIntercept(options.cleanPathname);
+	if (!intercept) return { kind: "none" };
+	const loadState = intercept.__loadState;
+	if (loadState?.page != null) intercept.page = loadState.page;
+	if (intercept.__pageLoader && intercept.page == null) {
+		const loading = loadState?.pageLoading ?? intercept.__pageLoader().then((page) => {
+			intercept.page = page;
+			if (loadState) {
+				loadState.page = page;
+				loadState.pageLoading = null;
+			}
+			return page;
+		}).catch((error) => {
+			if (loadState) loadState.pageLoading = null;
+			throw error;
+		});
+		if (loadState) loadState.pageLoading = loading;
+		await loading;
+	}
+	if (intercept.__loadInterceptLayouts) await loadAppInterceptLayouts(intercept);
+	const sourceRoute = await options.getSourceRoute(intercept.sourceRouteIndex);
+	if (!sourceRoute) return { kind: "none" };
+	if (sourceRoute === options.currentRoute) return {
+		kind: "current-route",
+		intercept
+	};
+	return {
+		kind: "source-route",
+		intercept,
+		sourceRoute
+	};
+}
+async function resolveAppPageInterceptionRerenderTarget(options) {
+	const interceptState = await resolveAppPageInterceptState({
+		cleanPathname: options.cleanPathname,
+		currentRoute: options.currentRoute,
+		findIntercept: options.findIntercept,
+		getRouteParamNames: options.getRouteParamNames,
+		getSourceRoute: options.getSourceRoute,
+		isRscRequest: options.isRscRequest,
+		toInterceptOpts: options.toInterceptOpts
+	});
+	if (interceptState.kind === "source-route") return {
+		interceptOpts: options.toInterceptOpts(interceptState.intercept),
+		navigationParams: interceptState.intercept.matchedParams,
+		params: pickRouteParams(interceptState.intercept.matchedParams, options.getRouteParamNames(interceptState.sourceRoute)),
+		route: interceptState.sourceRoute
+	};
+	return {
+		interceptOpts: interceptState.kind === "current-route" ? options.toInterceptOpts(interceptState.intercept) : void 0,
+		navigationParams: options.currentParams,
+		params: options.currentParams,
+		route: options.currentRoute
+	};
+}
+function resolveAppPageActionRerenderTarget(options) {
+	return resolveAppPageInterceptionRerenderTarget(options);
+}
+async function resolveAppPageIntercept(options) {
+	const interceptState = await resolveAppPageInterceptState({
+		cleanPathname: options.cleanPathname,
+		currentRoute: options.currentRoute,
+		findIntercept: options.findIntercept,
+		getRouteParamNames: options.getRouteParamNames,
+		getSourceRoute: options.getSourceRoute,
+		isRscRequest: options.isRscRequest,
+		toInterceptOpts: options.toInterceptOpts
+	});
+	if (interceptState.kind === "source-route") {
+		const renderRoute = interceptState.sourceRoute;
+		const interceptOpts = options.toInterceptOpts(interceptState.intercept);
+		const renderParams = pickRouteParams(interceptState.intercept.matchedParams, options.getRouteParamNames(interceptState.sourceRoute));
+		options.setNavigationContext({
+			params: options.resolveNavigationParams(renderRoute, interceptState.intercept.matchedParams, options.cleanPathname, interceptOpts),
+			pathname: options.cleanPathname,
+			searchParams: options.searchParams
+		});
+		const interceptElement = await options.buildPageElement(renderRoute, renderParams, interceptOpts, options.searchParams, options.layoutParamAccess);
+		return {
+			interceptOpts: void 0,
+			response: await options.renderInterceptResponse(renderRoute, interceptElement)
+		};
+	}
+	return {
+		interceptOpts: interceptState.kind === "current-route" ? options.toInterceptOpts(interceptState.intercept) : void 0,
+		response: null
+	};
+}
+async function buildAppPageElement(options) {
+	try {
+		return {
+			element: await options.buildPageElement(),
+			response: null
+		};
+	} catch (error) {
+		const buildSpecialError = options.resolveSpecialError(error);
+		const specialError = (buildSpecialError ? await options.probePageSpecialError?.() : null) ?? buildSpecialError;
+		if (specialError) return {
+			element: null,
+			response: await options.renderSpecialError(specialError)
+		};
+		const errorBoundaryResponse = await options.renderErrorBoundaryPage(error);
+		if (errorBoundaryResponse) return {
+			element: null,
+			response: errorBoundaryResponse
+		};
+		throw error;
+	}
+}
+//#endregion
+export { buildAppPageElement, resolveAppPageActionRerenderTarget, resolveAppPageGenerateStaticParamsSources, resolveAppPageIntercept, resolveAppPageInterceptMatch, resolveAppPageInterceptionRerenderTarget, validateAppPageDynamicParams };

package/dist/server/app-page-response.d.ts

@@ -0,0 +1,68 @@
+import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
+
+//#region src/server/app-page-response.d.ts
+type AppPageMiddlewareContext = {
+  headers: Headers | null;
+  status: number | null;
+};
+type AppPageResponseTiming = {
+  compileEnd?: number;
+  handlerStart: number;
+  renderEnd?: number;
+  responseKind: "html" | "rsc";
+};
+type AppPageResponsePolicy = {
+  cacheControl?: string;
+  cacheState?: "MISS" | "STATIC";
+};
+type ResolveAppPageResponsePolicyBaseOptions = {
+  isDraftMode: boolean;
+  isDynamicError: boolean;
+  isForceDynamic: boolean;
+  isForceStatic: boolean;
+  isProduction: boolean;
+  expireSeconds?: number;
+  revalidateSeconds: number | null;
+};
+type ResolveAppPageRscResponsePolicyOptions = {
+  dynamicUsedDuringBuild: boolean;
+} & ResolveAppPageResponsePolicyBaseOptions;
+type ResolveAppPageHtmlResponsePolicyOptions = {
+  dynamicUsedDuringRender: boolean;
+  isProgressiveActionRender?: boolean;
+  hasScriptNonce: boolean;
+} & ResolveAppPageResponsePolicyBaseOptions;
+type AppPageHtmlResponsePolicy = {
+  shouldWriteToCache: boolean;
+} & AppPageResponsePolicy;
+type BuildAppPageRscResponseOptions = {
+  dynamicStaleTimeSeconds?: number;
+  isEdgeRuntime?: boolean;
+  middlewareContext: AppPageMiddlewareContext;
+  mountedSlotsHeader?: string | null;
+  params?: Record<string, unknown>;
+  policy: AppPageResponsePolicy;
+  timing?: AppPageResponseTiming;
+};
+type BuildAppPageHtmlResponseOptions = {
+  draftCookie?: string | null; /** Combined preload `Link` header value (React hints + font preloads), already capped. */
+  linkHeader?: string;
+  isEdgeRuntime?: boolean;
+  middlewareContext: AppPageMiddlewareContext;
+  policy: AppPageResponsePolicy;
+  timing?: AppPageResponseTiming;
+};
+declare function resolveAppPageRscResponsePolicy(options: ResolveAppPageRscResponsePolicyOptions): AppPageResponsePolicy;
+declare function resolveAppPageHtmlResponsePolicy(options: ResolveAppPageHtmlResponsePolicyOptions): AppPageHtmlResponsePolicy;
+/**
+ * Mirror Next.js' edge-runtime marker (set in edge-ssr-app.ts). Only routes
+ * whose resolved segment config is `runtime = "edge"` should advertise it —
+ * nodejs-runtime routes must not, otherwise downstream consumers can't tell
+ * the configured runtime from the response. Centralized so every response
+ * construction site can opt in without re-deriving the header name.
+ */
+declare function applyEdgeRuntimeHeader(headers: Headers, isEdgeRuntime: boolean | undefined): void;
+declare function buildAppPageRscResponse(body: ReadableStream, options: BuildAppPageRscResponseOptions): Response;
+declare function buildAppPageHtmlResponse(body: ReadableStream, options: BuildAppPageHtmlResponseOptions): Response;
+//#endregion
+export { AppPageMiddlewareContext, AppPageResponseTiming, applyEdgeRuntimeHeader, buildAppPageHtmlResponse, buildAppPageRscResponse, mergeMiddlewareResponseHeaders, resolveAppPageHtmlResponsePolicy, resolveAppPageRscResponsePolicy };

package/dist/server/app-page-response.js

@@ -0,0 +1,120 @@
+import { VINEXT_DYNAMIC_STALE_TIME_HEADER, VINEXT_MOUNTED_SLOTS_HEADER, VINEXT_PARAMS_HEADER, VINEXT_TIMING_HEADER } from "./headers.js";
+import { setCacheStateHeaders } from "./cache-headers.js";
+import { NO_STORE_CACHE_CONTROL, STATIC_CACHE_CONTROL, buildRevalidateCacheControl } from "./cache-control.js";
+import { VINEXT_RSC_CONTENT_TYPE, VINEXT_RSC_VARY_HEADER, applyRscCompatibilityIdHeader } from "./app-rsc-cache-busting.js";
+import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
+//#region src/server/app-page-response.ts
+function applyTimingHeader(headers, timing) {
+	if (!timing) return;
+	const handlerStart = Math.round(timing.handlerStart);
+	const compileMs = timing.compileEnd !== void 0 ? Math.round(timing.compileEnd - timing.handlerStart) : -1;
+	const renderMs = timing.responseKind === "html" && timing.renderEnd !== void 0 && timing.compileEnd !== void 0 ? Math.round(timing.renderEnd - timing.compileEnd) : -1;
+	headers.set(VINEXT_TIMING_HEADER, `${handlerStart},${compileMs},${renderMs}`);
+}
+function applyDynamicStaleTimeHeader(headers, dynamicStaleTimeSeconds) {
+	if (dynamicStaleTimeSeconds !== void 0 && Number.isInteger(dynamicStaleTimeSeconds) && dynamicStaleTimeSeconds >= 0) headers.set(VINEXT_DYNAMIC_STALE_TIME_HEADER, String(dynamicStaleTimeSeconds));
+}
+function resolveAppPageRscResponsePolicy(options) {
+	if (options.isDraftMode) return { cacheControl: NO_STORE_CACHE_CONTROL };
+	if (options.isForceDynamic || options.dynamicUsedDuringBuild) return { cacheControl: NO_STORE_CACHE_CONTROL };
+	if (options.revalidateSeconds === 0) return { cacheControl: NO_STORE_CACHE_CONTROL };
+	if ((options.isForceStatic || options.isDynamicError) && !options.revalidateSeconds || options.revalidateSeconds === Infinity) return {
+		cacheControl: STATIC_CACHE_CONTROL,
+		cacheState: "STATIC"
+	};
+	if (options.revalidateSeconds) return {
+		cacheControl: buildRevalidateCacheControl(options.revalidateSeconds, options.expireSeconds),
+		cacheState: options.isProduction ? "MISS" : void 0
+	};
+	return {};
+}
+function resolveAppPageHtmlResponsePolicy(options) {
+	if (options.isDraftMode) return {
+		cacheControl: NO_STORE_CACHE_CONTROL,
+		shouldWriteToCache: false
+	};
+	if (options.isForceDynamic) return {
+		cacheControl: NO_STORE_CACHE_CONTROL,
+		shouldWriteToCache: false
+	};
+	if (options.hasScriptNonce) return {
+		cacheControl: NO_STORE_CACHE_CONTROL,
+		shouldWriteToCache: false
+	};
+	if (options.isProgressiveActionRender) return {
+		cacheControl: NO_STORE_CACHE_CONTROL,
+		shouldWriteToCache: false
+	};
+	if (options.revalidateSeconds === 0) return {
+		cacheControl: NO_STORE_CACHE_CONTROL,
+		shouldWriteToCache: false
+	};
+	if ((options.isForceStatic || options.isDynamicError) && options.revalidateSeconds === null) return {
+		cacheControl: STATIC_CACHE_CONTROL,
+		cacheState: "STATIC",
+		shouldWriteToCache: false
+	};
+	if (options.dynamicUsedDuringRender) return {
+		cacheControl: NO_STORE_CACHE_CONTROL,
+		shouldWriteToCache: false
+	};
+	if (options.revalidateSeconds !== null && options.revalidateSeconds > 0 && options.revalidateSeconds !== Infinity) return {
+		cacheControl: buildRevalidateCacheControl(options.revalidateSeconds, options.expireSeconds),
+		cacheState: options.isProduction ? "MISS" : void 0,
+		shouldWriteToCache: options.isProduction
+	};
+	if (options.revalidateSeconds === Infinity) return {
+		cacheControl: STATIC_CACHE_CONTROL,
+		cacheState: options.isProduction ? "MISS" : "STATIC",
+		shouldWriteToCache: options.isProduction
+	};
+	return { shouldWriteToCache: false };
+}
+/**
+* Mirror Next.js' edge-runtime marker (set in edge-ssr-app.ts). Only routes
+* whose resolved segment config is `runtime = "edge"` should advertise it —
+* nodejs-runtime routes must not, otherwise downstream consumers can't tell
+* the configured runtime from the response. Centralized so every response
+* construction site can opt in without re-deriving the header name.
+*/
+function applyEdgeRuntimeHeader(headers, isEdgeRuntime) {
+	if (isEdgeRuntime) headers.set("x-edge-runtime", "1");
+}
+function buildAppPageRscResponse(body, options) {
+	const headers = new Headers({
+		"Content-Type": VINEXT_RSC_CONTENT_TYPE,
+		Vary: VINEXT_RSC_VARY_HEADER
+	});
+	applyEdgeRuntimeHeader(headers, options.isEdgeRuntime);
+	if (options.params && Object.keys(options.params).length > 0) headers.set(VINEXT_PARAMS_HEADER, encodeURIComponent(JSON.stringify(options.params)));
+	if (options.mountedSlotsHeader) headers.set(VINEXT_MOUNTED_SLOTS_HEADER, options.mountedSlotsHeader);
+	applyDynamicStaleTimeHeader(headers, options.dynamicStaleTimeSeconds);
+	if (options.policy.cacheControl) headers.set("Cache-Control", options.policy.cacheControl);
+	if (options.policy.cacheState) setCacheStateHeaders(headers, options.policy.cacheState);
+	mergeMiddlewareResponseHeaders(headers, options.middlewareContext.headers);
+	applyRscCompatibilityIdHeader(headers);
+	applyTimingHeader(headers, options.timing);
+	return new Response(body, {
+		status: options.middlewareContext.status ?? 200,
+		headers
+	});
+}
+function buildAppPageHtmlResponse(body, options) {
+	const headers = new Headers({
+		"Content-Type": "text/html; charset=utf-8",
+		Vary: VINEXT_RSC_VARY_HEADER
+	});
+	applyEdgeRuntimeHeader(headers, options.isEdgeRuntime);
+	if (options.policy.cacheControl) headers.set("Cache-Control", options.policy.cacheControl);
+	if (options.policy.cacheState) setCacheStateHeaders(headers, options.policy.cacheState);
+	if (options.draftCookie) headers.append("Set-Cookie", options.draftCookie);
+	if (options.linkHeader) headers.set("Link", options.linkHeader);
+	mergeMiddlewareResponseHeaders(headers, options.middlewareContext.headers);
+	applyTimingHeader(headers, options.timing);
+	return new Response(body, {
+		status: options.middlewareContext.status ?? 200,
+		headers
+	});
+}
+//#endregion
+export { applyEdgeRuntimeHeader, buildAppPageHtmlResponse, buildAppPageRscResponse, mergeMiddlewareResponseHeaders, resolveAppPageHtmlResponsePolicy, resolveAppPageRscResponsePolicy };