@qzsy/vinext 0.1.7

package/dist/server/app-route-handler-dispatch.js

@@ -0,0 +1,163 @@
+import { createRequestContext, runWithRequestContext } from "../shims/unified-request-context.js";
+import { getRequestExecutionContext } from "../shims/request-context.js";
+import { reportRequestError } from "./instrumentation.js";
+import { consumeDynamicUsage, getAndClearPendingCookies, getDraftModeCookieHeader, markDynamicUsage, setHeadersAccessPhase } from "../shims/headers.js";
+import { ensureFetchPatch, getCollectedFetchTags, setCurrentFetchCacheMode, setCurrentFetchSoftTags, setCurrentForceDynamicFetchDefault } from "../shims/fetch-cache.js";
+import { setNavigationContext } from "../shims/navigation-context-state.js";
+import { makeThenableParams } from "../shims/thenable-params.js";
+import "../shims/navigation.js";
+import { buildPageCacheTags } from "./implicit-tags.js";
+import { applyRouteHandlerMiddlewareContext } from "./app-route-handler-response.js";
+import { isKnownDynamicAppRoute, isValidHTTPMethod } from "./app-route-handler-runtime.js";
+import { createStaticGenerationHeadersContext } from "./app-static-generation.js";
+import { getAppRouteHandlerRevalidateSeconds, hasAppRouteHandlerDefaultExport, resolveAppRouteHandlerMethod, shouldReadAppRouteHandlerCache } from "./app-route-handler-policy.js";
+import { executeAppRouteHandler } from "./app-route-handler-execution.js";
+import { readAppRouteHandlerCacheResponse } from "./app-route-handler-cache.js";
+import { resolveAppRouteHandlerFetchCacheMode } from "./app-segment-config.js";
+//#region src/server/app-route-handler-dispatch.ts
+function isAppRouteHandlerFunction(value) {
+	return typeof value === "function";
+}
+function buildRouteHandlerPageCacheTags(pathname, extraTags, routeSegments) {
+	return buildPageCacheTags(pathname, extraTags, routeSegments, "route");
+}
+async function runInRouteHandlerRevalidationContext(options, renderFn) {
+	await runWithRequestContext(createRequestContext({
+		headersContext: createStaticGenerationHeadersContext({
+			draftModeSecret: options.draftModeSecret,
+			dynamicConfig: options.dynamicConfig,
+			routeKind: "route",
+			routePattern: options.routePattern
+		}),
+		executionContext: getRequestExecutionContext(),
+		unstableCacheRevalidation: "foreground"
+	}), async () => {
+		ensureFetchPatch();
+		setCurrentFetchSoftTags(buildRouteHandlerPageCacheTags(options.cleanPathname, [], options.routeSegments));
+		setCurrentFetchCacheMode(options.fetchCacheMode);
+		setCurrentForceDynamicFetchDefault(options.dynamicConfig === "force-dynamic");
+		await renderFn();
+	});
+}
+async function dispatchAppRouteHandler(options) {
+	const { route } = options;
+	const handler = route.routeHandler;
+	const method = options.request.method.toUpperCase();
+	const revalidateSeconds = getAppRouteHandlerRevalidateSeconds(handler);
+	const isDevelopment = options.isDevelopment ?? process.env.NODE_ENV === "development";
+	const isProduction = options.isProduction ?? process.env.NODE_ENV === "production";
+	if (hasAppRouteHandlerDefaultExport(handler) && isDevelopment) console.error("[vinext] Detected default export in route handler " + route.pattern + ". Export a named export for each HTTP method instead.");
+	if (!isValidHTTPMethod(method)) {
+		options.clearRequestContext();
+		return applyRouteHandlerMiddlewareContext(new Response(null, { status: 400 }), options.middlewareContext);
+	}
+	const { allowHeaderForOptions, handlerFn, isAutoHead, shouldAutoRespondToOptions } = resolveAppRouteHandlerMethod(handler, method);
+	if (shouldAutoRespondToOptions) {
+		options.clearRequestContext();
+		return applyRouteHandlerMiddlewareContext(new Response(null, {
+			status: 204,
+			headers: { Allow: allowHeaderForOptions }
+		}), options.middlewareContext);
+	}
+	const resolvedHandlerFn = isAppRouteHandlerFunction(handlerFn) ? handlerFn : void 0;
+	const fetchCacheMode = resolveAppRouteHandlerFetchCacheMode(handler);
+	setCurrentFetchCacheMode(fetchCacheMode);
+	setCurrentForceDynamicFetchDefault(handler.dynamic === "force-dynamic");
+	if (revalidateSeconds !== null && shouldReadAppRouteHandlerCache({
+		dynamicConfig: handler.dynamic,
+		handlerFn: resolvedHandlerFn,
+		isAutoHead,
+		isKnownDynamic: isKnownDynamicAppRoute(route.pattern),
+		isProduction,
+		method,
+		revalidateSeconds
+	}) && resolvedHandlerFn) {
+		const cachedRouteResponse = await readAppRouteHandlerCacheResponse({
+			basePath: options.basePath,
+			buildPageCacheTags(pathname, extraTags) {
+				return buildRouteHandlerPageCacheTags(pathname, extraTags, route.routeSegments);
+			},
+			cleanPathname: options.cleanPathname,
+			clearRequestContext: options.clearRequestContext,
+			consumeDynamicUsage,
+			dynamicConfig: handler.dynamic,
+			getCollectedFetchTags,
+			handlerFn: resolvedHandlerFn,
+			i18n: options.i18n,
+			trailingSlash: options.trailingSlash,
+			isAutoHead,
+			isrDebug: options.isrDebug,
+			isrGet: options.isrGet,
+			isrRouteKey: options.isrRouteKey,
+			isrSet: options.isrSet,
+			markDynamicUsage,
+			middlewareContext: options.middlewareContext,
+			params: options.params,
+			requestUrl: options.request.url,
+			revalidateSearchParams: options.searchParams,
+			expireSeconds: options.expireSeconds,
+			revalidateSeconds,
+			routePattern: route.pattern,
+			runInRevalidationContext(renderFn) {
+				return runInRouteHandlerRevalidationContext({
+					cleanPathname: options.cleanPathname,
+					draftModeSecret: options.draftModeSecret,
+					dynamicConfig: handler.dynamic,
+					fetchCacheMode,
+					routePattern: route.pattern,
+					routeSegments: route.routeSegments
+				}, renderFn);
+			},
+			scheduleBackgroundRegeneration(key, renderFn) {
+				options.scheduleBackgroundRegeneration(key, renderFn, {
+					routerKind: "App Router",
+					routePath: route.pattern,
+					routeType: "route"
+				});
+			},
+			setHeadersAccessPhase,
+			setNavigationContext
+		});
+		if (cachedRouteResponse) return cachedRouteResponse;
+	}
+	if (resolvedHandlerFn) return executeAppRouteHandler({
+		basePath: options.basePath,
+		buildPageCacheTags(pathname, extraTags) {
+			return buildRouteHandlerPageCacheTags(pathname, extraTags, route.routeSegments);
+		},
+		cleanPathname: options.cleanPathname,
+		clearRequestContext: options.clearRequestContext,
+		consumeDynamicUsage,
+		draftModeSecret: options.draftModeSecret,
+		executionContext: getRequestExecutionContext(),
+		getAndClearPendingCookies,
+		getCollectedFetchTags,
+		getDraftModeCookieHeader,
+		handler,
+		handlerFn: resolvedHandlerFn,
+		i18n: options.i18n,
+		trailingSlash: options.trailingSlash,
+		isAutoHead,
+		isProduction,
+		isrDebug: options.isrDebug,
+		isrRouteKey: options.isrRouteKey,
+		isrSet: options.isrSet,
+		markDynamicUsage,
+		method,
+		middlewareContext: options.middlewareContext,
+		middlewareRequestHeaders: options.middlewareRequestHeaders,
+		params: options.params === null ? null : makeThenableParams(options.params),
+		reportRequestError(error, request, context) {
+			reportRequestError(error, request, context);
+		},
+		request: options.request,
+		expireSeconds: options.expireSeconds,
+		revalidateSeconds,
+		routePattern: route.pattern,
+		setHeadersAccessPhase
+	});
+	options.clearRequestContext();
+	return applyRouteHandlerMiddlewareContext(new Response(null, { status: 405 }), options.middlewareContext);
+}
+//#endregion
+export { dispatchAppRouteHandler };

package/dist/server/app-route-handler-execution.d.ts

@@ -0,0 +1,86 @@
+import { NextI18nConfig } from "../config/next-config.js";
+import { CachedRouteValue } from "../shims/cache-handler.js";
+import { ExecutionContextLike } from "../shims/request-context.js";
+import { NextRequest } from "../shims/server.js";
+import { HeadersAccessPhase } from "../shims/headers.js";
+import { RouteHandlerMiddlewareContext } from "./app-route-handler-response.js";
+import { AppRouteHandlerModule } from "./app-route-handler-policy.js";
+
+//#region src/server/app-route-handler-execution.d.ts
+type AppRouteParams = Record<string, string | string[]>;
+type AppRouteDynamicUsageFn = () => boolean;
+type MarkAppRouteDynamicUsageFn = () => void;
+/**
+ * Route handler context.
+ *
+ * `params` is `null` for non-dynamic routes (no `[param]` segments) so that
+ * user code like `params ? await params : null` resolves to `null`, matching
+ * Next.js behavior. For dynamic routes it's a thenable that resolves to the
+ * matched params object.
+ *
+ * See: test/e2e/app-dir/app-routes/app-custom-routes.test.ts in Next.js for
+ * the authoritative assertion (`expect(meta.params).toEqual(null)`).
+ */
+type AppRouteHandlerFunction = (request: NextRequest, context: {
+  params: AppRouteParams | null;
+}) => Response | Promise<Response>;
+type RouteHandlerCacheSetter = (key: string, data: CachedRouteValue, revalidateSeconds: number, tags: string[], expireSeconds?: number) => Promise<void>;
+type AppRouteErrorReporter = (error: Error, request: {
+  path: string;
+  method: string;
+  headers: Record<string, string>;
+}, route: {
+  routerKind: "App Router";
+  routePath: string;
+  routeType: "route";
+}) => void;
+type AppRouteDebugLogger = (event: string, detail: string) => void;
+type RunAppRouteHandlerOptions = {
+  basePath?: string;
+  consumeDynamicUsage: AppRouteDynamicUsageFn;
+  draftModeSecret?: string;
+  dynamicConfig?: string;
+  handlerFn: AppRouteHandlerFunction;
+  i18n?: NextI18nConfig | null;
+  trailingSlash?: boolean;
+  markDynamicUsage: MarkAppRouteDynamicUsageFn;
+  middlewareRequestHeaders?: Headers | null;
+  /**
+   * `null` for non-dynamic routes. Passed through to the handler context
+   * unchanged — callers are expected to compute this from `route.isDynamic`.
+   */
+  params: AppRouteParams | null;
+  request: Request;
+  routePattern?: string;
+  setHeadersAccessPhase?: (phase: HeadersAccessPhase) => HeadersAccessPhase;
+};
+type RunAppRouteHandlerResult = {
+  dynamicUsedInHandler: boolean;
+  response: Response;
+};
+type ExecuteAppRouteHandlerOptions = {
+  buildPageCacheTags: (pathname: string, extraTags: string[]) => string[];
+  clearRequestContext: () => void;
+  cleanPathname: string;
+  executionContext: ExecutionContextLike | null;
+  getAndClearPendingCookies: () => string[];
+  getCollectedFetchTags: () => string[];
+  getDraftModeCookieHeader: () => string | null | undefined;
+  handler: AppRouteHandlerModule;
+  isAutoHead: boolean;
+  isProduction: boolean;
+  isrDebug?: AppRouteDebugLogger;
+  isrRouteKey: (pathname: string) => string;
+  isrSet: RouteHandlerCacheSetter;
+  method: string;
+  middlewareContext: RouteHandlerMiddlewareContext;
+  reportRequestError: AppRouteErrorReporter;
+  expireSeconds?: number;
+  revalidateSeconds: number | null;
+  routePattern: string;
+  setHeadersAccessPhase: (phase: HeadersAccessPhase) => HeadersAccessPhase;
+} & RunAppRouteHandlerOptions;
+declare function runAppRouteHandler(options: RunAppRouteHandlerOptions): Promise<RunAppRouteHandlerResult>;
+declare function executeAppRouteHandler(options: ExecuteAppRouteHandlerOptions): Promise<Response>;
+//#endregion
+export { AppRouteDebugLogger, AppRouteDynamicUsageFn, AppRouteHandlerFunction, AppRouteParams, MarkAppRouteDynamicUsageFn, RouteHandlerCacheSetter, executeAppRouteHandler, runAppRouteHandler };

package/dist/server/app-route-handler-execution.js

@@ -0,0 +1,128 @@
+import { setHeadersContext } from "../shims/headers.js";
+import { isPossibleAppRouteActionRequest } from "./app-action-request.js";
+import { applyRouteHandlerMiddlewareContext, applyRouteHandlerRevalidateHeader, assertSupportedAppRouteHandlerResponse, buildAppRouteCacheValue, finalizeRouteHandlerResponse, markRouteHandlerCacheMiss } from "./app-route-handler-response.js";
+import { createTrackedAppRouteRequest, markKnownDynamicAppRoute } from "./app-route-handler-runtime.js";
+import { createStaticGenerationHeadersContext, getAppRouteStaticGenerationErrorMessage } from "./app-static-generation.js";
+import { resolveAppRouteHandlerSpecialError, shouldApplyAppRouteHandlerRevalidateHeader, shouldWriteAppRouteHandlerCache } from "./app-route-handler-policy.js";
+//#region src/server/app-route-handler-execution.ts
+function configureAppRouteStaticGenerationContext(options) {
+	if (options.dynamicConfig === "force-static" || options.dynamicConfig === "error") {
+		setHeadersContext(createStaticGenerationHeadersContext({
+			draftModeSecret: options.draftModeSecret,
+			dynamicConfig: options.dynamicConfig,
+			routeKind: "route",
+			routePattern: options.routePattern
+		}));
+		options.setHeadersAccessPhase?.("route-handler");
+	}
+}
+async function runAppRouteHandler(options) {
+	options.consumeDynamicUsage();
+	configureAppRouteStaticGenerationContext(options);
+	const trackedRequest = createTrackedAppRouteRequest(options.request, {
+		basePath: options.basePath,
+		i18n: options.i18n,
+		trailingSlash: options.trailingSlash,
+		middlewareHeaders: options.middlewareRequestHeaders,
+		onDynamicAccess() {
+			options.markDynamicUsage();
+		},
+		requestMode: options.dynamicConfig === "force-static" || options.dynamicConfig === "error" ? options.dynamicConfig : "auto",
+		staticGenerationErrorMessage(expression) {
+			return getAppRouteStaticGenerationErrorMessage(options.routePattern, expression);
+		}
+	});
+	const response = await options.handlerFn(trackedRequest.request, { params: options.params });
+	return {
+		dynamicUsedInHandler: options.consumeDynamicUsage(),
+		response
+	};
+}
+async function executeAppRouteHandler(options) {
+	const previousHeadersPhase = options.setHeadersAccessPhase("route-handler");
+	try {
+		const { dynamicUsedInHandler, response } = await runAppRouteHandler({
+			...options,
+			dynamicConfig: options.handler.dynamic
+		});
+		assertSupportedAppRouteHandlerResponse(response);
+		const handlerSetCacheControl = response.headers.has("cache-control");
+		if (dynamicUsedInHandler) markKnownDynamicAppRoute(options.routePattern);
+		const routeTags = options.buildPageCacheTags(options.cleanPathname, options.getCollectedFetchTags());
+		if (shouldApplyAppRouteHandlerRevalidateHeader({
+			dynamicUsedInHandler,
+			handlerSetCacheControl,
+			isAutoHead: options.isAutoHead,
+			method: options.method,
+			revalidateSeconds: options.revalidateSeconds
+		})) {
+			const revalidateSeconds = options.revalidateSeconds;
+			if (revalidateSeconds == null) throw new Error("Expected route handler revalidate seconds");
+			applyRouteHandlerRevalidateHeader(response, revalidateSeconds, options.expireSeconds, routeTags);
+		}
+		if (shouldWriteAppRouteHandlerCache({
+			dynamicConfig: options.handler.dynamic,
+			dynamicUsedInHandler,
+			handlerSetCacheControl,
+			isAutoHead: options.isAutoHead,
+			isProduction: options.isProduction,
+			method: options.method,
+			revalidateSeconds: options.revalidateSeconds
+		})) {
+			markRouteHandlerCacheMiss(response);
+			const routeClone = response.clone();
+			const routeKey = options.isrRouteKey(options.cleanPathname);
+			const revalidateSeconds = options.revalidateSeconds;
+			if (revalidateSeconds == null) throw new Error("Expected route handler cache revalidate seconds");
+			const routeWritePromise = (async () => {
+				try {
+					const routeCacheValue = await buildAppRouteCacheValue(routeClone);
+					await options.isrSet(routeKey, routeCacheValue, revalidateSeconds, routeTags, options.expireSeconds);
+					options.isrDebug?.("route cache written", routeKey);
+				} catch (cacheErr) {
+					console.error("[vinext] ISR route cache write error:", cacheErr);
+				}
+			})();
+			options.executionContext?.waitUntil(routeWritePromise);
+		}
+		const pendingCookies = options.getAndClearPendingCookies();
+		const draftCookie = options.getDraftModeCookieHeader();
+		options.clearRequestContext();
+		return applyRouteHandlerMiddlewareContext(finalizeRouteHandlerResponse(response, {
+			pendingCookies,
+			draftCookie,
+			isHead: options.isAutoHead
+		}), options.middlewareContext);
+	} catch (error) {
+		const pendingCookies = options.getAndClearPendingCookies();
+		const draftCookie = options.getDraftModeCookieHeader();
+		const specialError = resolveAppRouteHandlerSpecialError(error, options.request.url, { isAction: isPossibleAppRouteActionRequest(options.request) });
+		options.clearRequestContext();
+		if (specialError) {
+			if (specialError.kind === "redirect") return applyRouteHandlerMiddlewareContext(finalizeRouteHandlerResponse(new Response(null, {
+				status: specialError.statusCode,
+				headers: { Location: specialError.location }
+			}), {
+				pendingCookies,
+				draftCookie,
+				isHead: options.isAutoHead
+			}), options.middlewareContext);
+			return applyRouteHandlerMiddlewareContext(new Response(null, { status: specialError.statusCode }), options.middlewareContext);
+		}
+		console.error("[vinext] Route handler error:", error);
+		options.reportRequestError(error instanceof Error ? error : new Error(String(error)), {
+			path: options.cleanPathname,
+			method: options.request.method,
+			headers: Object.fromEntries(options.request.headers.entries())
+		}, {
+			routerKind: "App Router",
+			routePath: options.routePattern,
+			routeType: "route"
+		});
+		return applyRouteHandlerMiddlewareContext(new Response(null, { status: 500 }), options.middlewareContext);
+	} finally {
+		options.setHeadersAccessPhase(previousHeadersPhase);
+	}
+}
+//#endregion
+export { executeAppRouteHandler, runAppRouteHandler };

package/dist/server/app-route-handler-policy.d.ts

@@ -0,0 +1,55 @@
+import { isPossibleAppRouteActionRequest } from "./app-action-request.js";
+import { RouteHandlerHttpMethod, RouteHandlerModule } from "./app-route-handler-runtime.js";
+
+//#region src/server/app-route-handler-policy.d.ts
+type AppRouteHandlerModule = {
+  dynamic?: string;
+  fetchCache?: unknown;
+  revalidate?: unknown;
+} & RouteHandlerModule;
+type AppRouteHandlerFunction = (...args: unknown[]) => unknown;
+type ResolvedAppRouteHandlerMethod = {
+  allowHeaderForOptions: string;
+  exportedMethods: RouteHandlerHttpMethod[];
+  handlerFn: AppRouteHandlerFunction | undefined;
+  isAutoHead: boolean;
+  shouldAutoRespondToOptions: boolean;
+};
+type AppRouteHandlerCacheReadOptions = {
+  dynamicConfig?: string;
+  handlerFn: unknown;
+  isAutoHead: boolean;
+  isKnownDynamic: boolean;
+  isProduction: boolean;
+  method: string;
+  revalidateSeconds: number | null;
+};
+type AppRouteHandlerResponseCacheOptions = {
+  dynamicConfig?: string;
+  dynamicUsedInHandler: boolean;
+  handlerSetCacheControl: boolean;
+  isAutoHead: boolean;
+  isProduction: boolean;
+  method: string;
+  revalidateSeconds: number | null;
+};
+type AppRouteHandlerSpecialError = {
+  kind: "redirect";
+  location: string;
+  statusCode: number;
+} | {
+  kind: "status";
+  statusCode: number;
+};
+type AppRouteHandlerSpecialErrorOptions = {
+  isAction: boolean;
+};
+declare function getAppRouteHandlerRevalidateSeconds(handler: Pick<AppRouteHandlerModule, "revalidate">): number | null;
+declare function hasAppRouteHandlerDefaultExport(handler: RouteHandlerModule): boolean;
+declare function resolveAppRouteHandlerMethod(handler: AppRouteHandlerModule, method: string): ResolvedAppRouteHandlerMethod;
+declare function shouldReadAppRouteHandlerCache(options: AppRouteHandlerCacheReadOptions): boolean;
+declare function shouldApplyAppRouteHandlerRevalidateHeader(options: Omit<AppRouteHandlerResponseCacheOptions, "dynamicConfig" | "isProduction">): boolean;
+declare function shouldWriteAppRouteHandlerCache(options: AppRouteHandlerResponseCacheOptions): boolean;
+declare function resolveAppRouteHandlerSpecialError(error: unknown, requestUrl: string, options?: AppRouteHandlerSpecialErrorOptions): AppRouteHandlerSpecialError | null;
+//#endregion
+export { AppRouteHandlerModule, getAppRouteHandlerRevalidateSeconds, hasAppRouteHandlerDefaultExport, isPossibleAppRouteActionRequest, resolveAppRouteHandlerMethod, resolveAppRouteHandlerSpecialError, shouldApplyAppRouteHandlerRevalidateHeader, shouldReadAppRouteHandlerCache, shouldWriteAppRouteHandlerCache };

package/dist/server/app-route-handler-policy.js

@@ -0,0 +1,58 @@
+import { parseNextHttpErrorDigest, parseNextRedirectDigest } from "./next-error-digest.js";
+import { isPossibleAppRouteActionRequest } from "./app-action-request.js";
+import { buildRouteHandlerAllowHeader, collectRouteHandlerMethods } from "./app-route-handler-runtime.js";
+//#region src/server/app-route-handler-policy.ts
+function getAppRouteHandlerRevalidateSeconds(handler) {
+	const { revalidate } = handler;
+	if (revalidate === false) return Infinity;
+	if (typeof revalidate !== "number" || !Number.isFinite(revalidate) || revalidate < 0) return null;
+	return revalidate;
+}
+function hasAppRouteHandlerDefaultExport(handler) {
+	return typeof handler.default === "function";
+}
+function resolveAppRouteHandlerMethod(handler, method) {
+	const exportedMethods = collectRouteHandlerMethods(handler);
+	const allowHeaderForOptions = buildRouteHandlerAllowHeader(exportedMethods);
+	const shouldAutoRespondToOptions = method === "OPTIONS" && typeof handler.OPTIONS !== "function";
+	let handlerFn = typeof handler[method] === "function" ? handler[method] : void 0;
+	let isAutoHead = false;
+	if (method === "HEAD" && typeof handler.HEAD !== "function" && typeof handler.GET === "function") {
+		handlerFn = handler.GET;
+		isAutoHead = true;
+	}
+	return {
+		allowHeaderForOptions,
+		exportedMethods,
+		handlerFn,
+		isAutoHead,
+		shouldAutoRespondToOptions
+	};
+}
+function shouldReadAppRouteHandlerCache(options) {
+	return options.isProduction && options.revalidateSeconds !== null && options.revalidateSeconds > 0 && options.revalidateSeconds !== Infinity && options.dynamicConfig !== "force-dynamic" && !options.isKnownDynamic && (options.method === "GET" || options.isAutoHead) && typeof options.handlerFn === "function";
+}
+function shouldApplyAppRouteHandlerRevalidateHeader(options) {
+	return options.revalidateSeconds !== null && !options.dynamicUsedInHandler && (options.method === "GET" || options.isAutoHead) && !options.handlerSetCacheControl;
+}
+function shouldWriteAppRouteHandlerCache(options) {
+	return options.isProduction && options.revalidateSeconds !== null && options.revalidateSeconds > 0 && options.revalidateSeconds !== Infinity && options.dynamicConfig !== "force-dynamic" && shouldApplyAppRouteHandlerRevalidateHeader(options);
+}
+function resolveAppRouteHandlerSpecialError(error, requestUrl, options) {
+	if (!(error && typeof error === "object" && "digest" in error)) return null;
+	const digest = String(error.digest);
+	const redirect = parseNextRedirectDigest(digest);
+	if (redirect) return {
+		kind: "redirect",
+		location: new URL(redirect.url, requestUrl).toString(),
+		statusCode: options?.isAction ? 303 : redirect.status
+	};
+	const httpError = parseNextHttpErrorDigest(digest);
+	if (httpError) return {
+		kind: "status",
+		statusCode: httpError.status
+	};
+	return null;
+}
+//#endregion
+export { getAppRouteHandlerRevalidateSeconds, hasAppRouteHandlerDefaultExport, isPossibleAppRouteActionRequest, resolveAppRouteHandlerMethod, resolveAppRouteHandlerSpecialError, shouldApplyAppRouteHandlerRevalidateHeader, shouldReadAppRouteHandlerCache, shouldWriteAppRouteHandlerCache };

package/dist/server/app-route-handler-response.d.ts

@@ -0,0 +1,28 @@
+import { CacheControlMetadata, CachedRouteValue } from "../shims/cache-handler.js";
+
+//#region src/server/app-route-handler-response.d.ts
+type RouteHandlerMiddlewareContext = {
+  headers: Headers | null;
+  status: number | null;
+};
+type BuildRouteHandlerCachedResponseOptions = {
+  cacheControl?: CacheControlMetadata;
+  cacheState: "HIT" | "STALE";
+  expireSeconds?: number;
+  isHead: boolean;
+  revalidateSeconds: number;
+};
+type FinalizeRouteHandlerResponseOptions = {
+  pendingCookies: string[];
+  draftCookie?: string | null;
+  isHead: boolean;
+};
+declare function applyRouteHandlerMiddlewareContext(response: Response, middlewareContext: RouteHandlerMiddlewareContext): Response;
+declare function assertSupportedAppRouteHandlerResponse(response: Response): void;
+declare function buildRouteHandlerCachedResponse(cachedValue: CachedRouteValue, options: BuildRouteHandlerCachedResponseOptions): Response;
+declare function applyRouteHandlerRevalidateHeader(response: Response, revalidateSeconds: number, expireSeconds?: number, tags?: readonly string[]): void;
+declare function markRouteHandlerCacheMiss(response: Response): void;
+declare function buildAppRouteCacheValue(response: Response): Promise<CachedRouteValue>;
+declare function finalizeRouteHandlerResponse(response: Response, options: FinalizeRouteHandlerResponseOptions): Response;
+//#endregion
+export { RouteHandlerMiddlewareContext, applyRouteHandlerMiddlewareContext, applyRouteHandlerRevalidateHeader, assertSupportedAppRouteHandlerResponse, buildAppRouteCacheValue, buildRouteHandlerCachedResponse, finalizeRouteHandlerResponse, markRouteHandlerCacheMiss };

package/dist/server/app-route-handler-response.js

@@ -0,0 +1,145 @@
+import "./headers.js";
+import { processMiddlewareHeaders } from "./request-pipeline.js";
+import { setCacheStateHeaders } from "./cache-headers.js";
+import { applyCdnResponseHeaders } from "./cache-control.js";
+import { buildAppRouteMissIsrCacheControl, decideIsr } from "./isr-decision.js";
+import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
+import { getSetCookieName } from "./cookie-utils.js";
+//#region src/server/app-route-handler-response.ts
+const APP_ROUTE_REWRITE_ERROR = "NextResponse.rewrite() was used in a app route handler, this is not currently supported. Please remove the invocation to continue.";
+const APP_ROUTE_NEXT_ERROR = "NextResponse.next() was used in a app route handler, this is not supported. See here for more info: https://nextjs.org/docs/messages/next-response-next-in-app-route-handler";
+function hasMiddlewareHeader(headers) {
+	for (const key of headers.keys()) if (key.startsWith("x-middleware-")) return true;
+	return false;
+}
+function applyRouteHandlerMiddlewareContext(response, middlewareContext) {
+	if (!middlewareContext.headers && middlewareContext.status == null) return response;
+	const responseHeaders = new Headers(response.headers);
+	mergeMiddlewareResponseHeaders(responseHeaders, middlewareContext.headers);
+	return new Response(response.body, {
+		status: middlewareContext.status ?? response.status,
+		statusText: response.statusText,
+		headers: responseHeaders
+	});
+}
+function assertSupportedAppRouteHandlerResponse(response) {
+	if (response.headers.has("x-middleware-rewrite")) throw new Error(APP_ROUTE_REWRITE_ERROR);
+	if (response.headers.get("x-middleware-next") === "1") throw new Error(APP_ROUTE_NEXT_ERROR);
+}
+function buildRouteHandlerCachedResponse(cachedValue, options) {
+	const headers = new Headers();
+	for (const [key, value] of Object.entries(cachedValue.headers)) if (Array.isArray(value)) for (const entry of value) headers.append(key, entry);
+	else headers.set(key, value);
+	setCacheStateHeaders(headers, options.cacheState);
+	const { cacheControl } = decideIsr({
+		cacheState: options.cacheState,
+		kind: "app-route",
+		revalidateSeconds: options.revalidateSeconds,
+		expireSeconds: options.expireSeconds,
+		cacheControlMeta: options.cacheControl
+	});
+	applyCdnResponseHeaders(headers, { cacheControl });
+	return new Response(options.isHead ? null : cachedValue.body, {
+		status: cachedValue.status,
+		headers
+	});
+}
+function applyRouteHandlerRevalidateHeader(response, revalidateSeconds, expireSeconds, tags) {
+	applyCdnResponseHeaders(response.headers, {
+		cacheControl: buildAppRouteMissIsrCacheControl(revalidateSeconds, expireSeconds),
+		tags
+	});
+}
+function markRouteHandlerCacheMiss(response) {
+	setCacheStateHeaders(response.headers, "MISS");
+}
+/**
+* Returns true when the given Set-Cookie string already declares any of the
+* attributes that follow the first `;` (case-insensitively). Used to detect
+* whether a user-emitted Set-Cookie line already carries an explicit `Path=`,
+* matching Next.js's `appendMutableCookies` which re-runs every cookie through
+* `ResponseCookies.set` (and therefore picks up the `Path=/` default for any
+* cookie that didn't supply one).
+*/
+function hasCookieAttribute(cookie, attributeName) {
+	const target = attributeName.toLowerCase();
+	let i = cookie.indexOf(";");
+	while (i !== -1) {
+		let start = i + 1;
+		while (start < cookie.length && cookie[start] === " ") start++;
+		const next = cookie.indexOf(";", start);
+		const end = next === -1 ? cookie.length : next;
+		const eq = cookie.indexOf("=", start);
+		const attrEnd = eq === -1 || eq > end ? end : eq;
+		if (cookie.slice(start, attrEnd).trim().toLowerCase() === target) return true;
+		i = next;
+	}
+	return false;
+}
+/**
+* Ensure each Set-Cookie line carries `Path=/` by default — Next.js's
+* `appendMutableCookies` re-runs every returned cookie through
+* `ResponseCookies.set`, which normalises a missing `path` to `/`. Without
+* this, a raw `new Response(..., { headers: [['Set-Cookie', 'bar=bar2']] })`
+* lands without `Path=/` and tests that assert on the full attribute set
+* (e.g. Next.js's `app-action.test.ts` route-handler-overrides case, see
+* issue #1484) break.
+*/
+function normalizeReturnedCookie(cookie) {
+	if (hasCookieAttribute(cookie, "Path")) return cookie;
+	return `${cookie.replace(/;\s*$/, "")}; Path=/`;
+}
+function applyMutableCookieFallbacks(headers, pendingCookies) {
+	if (pendingCookies.length === 0) return;
+	const returnedCookies = headers.getSetCookie();
+	const returnedCookieNames = /* @__PURE__ */ new Set();
+	for (const cookie of returnedCookies) {
+		const name = getSetCookieName(cookie);
+		if (name) returnedCookieNames.add(name);
+	}
+	const fallbackCookies = /* @__PURE__ */ new Map();
+	const unkeyedFallbackCookies = [];
+	for (const cookie of pendingCookies) {
+		const name = getSetCookieName(cookie);
+		if (!name) {
+			unkeyedFallbackCookies.push(cookie);
+			continue;
+		}
+		if (!returnedCookieNames.has(name)) fallbackCookies.set(name, cookie);
+	}
+	headers.delete("Set-Cookie");
+	for (const cookie of unkeyedFallbackCookies) headers.append("Set-Cookie", cookie);
+	for (const cookie of fallbackCookies.values()) headers.append("Set-Cookie", cookie);
+	for (const cookie of returnedCookies) headers.append("Set-Cookie", normalizeReturnedCookie(cookie));
+}
+async function buildAppRouteCacheValue(response) {
+	const body = await response.arrayBuffer();
+	const headers = {};
+	response.headers.forEach((value, key) => {
+		if (key === "set-cookie" || key === "X-Vinext-Cache".toLowerCase() || key === "x-nextjs-cache".toLowerCase() || key === "cache-control" || key.startsWith("x-middleware-")) return;
+		headers[key] = value;
+	});
+	const setCookies = response.headers.getSetCookie?.() ?? [];
+	if (setCookies.length > 0) headers["set-cookie"] = setCookies;
+	return {
+		kind: "APP_ROUTE",
+		body,
+		status: response.status,
+		headers
+	};
+}
+function finalizeRouteHandlerResponse(response, options) {
+	const { pendingCookies, draftCookie, isHead } = options;
+	if (pendingCookies.length === 0 && !draftCookie && !isHead && !hasMiddlewareHeader(response.headers)) return response;
+	const headers = new Headers(response.headers);
+	processMiddlewareHeaders(headers);
+	applyMutableCookieFallbacks(headers, pendingCookies);
+	if (draftCookie) headers.append("Set-Cookie", draftCookie);
+	return new Response(isHead ? null : response.body, {
+		status: response.status,
+		statusText: response.statusText,
+		headers
+	});
+}
+//#endregion
+export { applyRouteHandlerMiddlewareContext, applyRouteHandlerRevalidateHeader, assertSupportedAppRouteHandlerResponse, buildAppRouteCacheValue, buildRouteHandlerCachedResponse, finalizeRouteHandlerResponse, markRouteHandlerCacheMiss };