vinext 1.0.0-beta.8 → 1.0.0

package/dist/server/cacheability-manifest.js

@@ -0,0 +1,241 @@
+import { NEXT_ROUTER_STATE_TREE_HEADER, NEXT_URL_HEADER, VINEXT_INTERCEPTION_CONTEXT_HEADER, VINEXT_INTERCEPTION_ID_HEADER, VINEXT_MOUNTED_SLOTS_HEADER, VINEXT_RSC_RENDER_MODE_HEADER, VINEXT_RSC_STATE_FINGERPRINT_HEADER } from "./app-rsc-vary.js";
+import "./headers.js";
+import "./app-rsc-render-mode.js";
+//#region src/server/cacheability-manifest.ts
+const CACHEABILITY_MANIFEST_MODULE = "__vinext_cacheability_manifest.js";
+/** Request-stage projection of the manifest: the App page routes that can admit a query-free entry. */
+const CACHEABILITY_REQUEST_PROJECTION_MODULE = "__vinext_cacheability_request_projection.js";
+function cacheabilityManifestRouteKey(kind, pattern) {
+	return JSON.stringify([kind, pattern]);
+}
+function isRouteState(value) {
+	return value === "static-candidate" || value === "runtime-check";
+}
+function isRepresentation(value) {
+	return CACHEABILITY_REPRESENTATIONS.includes(value);
+}
+const CACHEABILITY_REPRESENTATIONS = [
+	"app-route",
+	"html",
+	"pages-data",
+	"rsc-full",
+	"rsc-loading-shell"
+];
+function expandPathToken(pathPrefix, token) {
+	if (!pathPrefix) return token;
+	const pathname = `${pathPrefix}${token}`;
+	return pathname === normalizeCacheabilityRoutePathname(pathname) ? pathname : null;
+}
+function parsePathList(value, pathPrefix) {
+	if (!Array.isArray(value) || value.length === 0 || !value.every((token, index, tokens) => typeof token === "string" && (pathPrefix !== void 0 || token.startsWith("/")) && expandPathToken(pathPrefix, token) !== null && (index === 0 || tokens[index - 1] < token))) return null;
+	return value;
+}
+function parseStaticPaths(value, pathPrefix) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+	const entries = Object.entries(value);
+	if (entries.length === 0) return null;
+	const parsed = {};
+	for (const [representation, paths] of entries) {
+		if (!isRepresentation(representation)) return null;
+		const parsedPaths = parsePathList(paths, pathPrefix);
+		if (!parsedPaths) return null;
+		parsed[representation] = parsedPaths;
+	}
+	return parsed;
+}
+function parseRoute(key, value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+	const route = value;
+	if (route.kind !== "app-page" && route.kind !== "app-route" && route.kind !== "pages-page" || typeof route.pattern !== "string" || !route.pattern.startsWith("/") || !isRouteState(route.state)) return null;
+	const pathPrefix = typeof route.pathPrefix === "string" && route.pathPrefix.startsWith("/") && new URL(route.pathPrefix, "http://vinext.local").pathname === route.pathPrefix ? route.pathPrefix : void 0;
+	const runtimePaths = route.runtimePaths === void 0 ? void 0 : parsePathList(route.runtimePaths, pathPrefix);
+	const staticPaths = route.staticPaths === void 0 ? void 0 : parseStaticPaths(route.staticPaths, pathPrefix);
+	const runtimeRepresentationPaths = route.runtimeRepresentationPaths === void 0 ? void 0 : parseStaticPaths(route.runtimeRepresentationPaths, pathPrefix);
+	const staticRepresentation = isRepresentation(route.staticRepresentation) ? route.staticRepresentation : void 0;
+	const runtimeRepresentation = isRepresentation(route.runtimeRepresentation) ? route.runtimeRepresentation : void 0;
+	if (route.allowUnknown !== void 0 && route.allowUnknown !== true || route.unknownState !== void 0 && route.unknownState !== "static-candidate" || route.unknownState !== void 0 && route.allowUnknown !== true || route.pathPrefix !== void 0 && pathPrefix === void 0 || route.staticRepresentation !== void 0 && staticRepresentation === void 0 || route.runtimeRepresentation !== void 0 && runtimeRepresentation === void 0 || runtimeRepresentation !== void 0 && (route.state !== "runtime-check" || route.allowUnknown !== void 0 || pathPrefix !== void 0 || staticRepresentation !== void 0 || runtimePaths !== void 0 || staticPaths !== void 0 || runtimeRepresentationPaths !== void 0) || staticRepresentation !== void 0 && (route.state !== "runtime-check" || /(^|\/):/.test(route.pattern) || runtimePaths !== void 0 || staticPaths !== void 0 || runtimeRepresentationPaths !== void 0) || pathPrefix !== void 0 && !runtimePaths && !staticPaths && !runtimeRepresentationPaths || route.runtimePaths !== void 0 && !runtimePaths || route.staticPaths !== void 0 && !staticPaths || route.runtimeRepresentationPaths !== void 0 && !runtimeRepresentationPaths || (runtimePaths || staticPaths || runtimeRepresentationPaths || route.allowUnknown === true) && route.state !== "runtime-check") return null;
+	const parsed = {
+		kind: route.kind,
+		pattern: route.pattern,
+		state: route.state,
+		...route.allowUnknown === true ? { allowUnknown: true } : {},
+		...route.unknownState === "static-candidate" ? { unknownState: "static-candidate" } : {},
+		...pathPrefix ? { pathPrefix } : {},
+		...runtimeRepresentation ? { runtimeRepresentation } : {},
+		...staticRepresentation ? { staticRepresentation } : {},
+		...runtimePaths ? { runtimePaths } : {},
+		...runtimeRepresentationPaths ? { runtimeRepresentationPaths } : {},
+		...staticPaths ? { staticPaths } : {}
+	};
+	const runtimePathSet = new Set((runtimePaths ?? []).map((token) => expandPathToken(pathPrefix, token)));
+	for (const tokens of Object.values(staticPaths ?? {})) for (const token of tokens ?? []) if (runtimePathSet.has(expandPathToken(pathPrefix, token))) return null;
+	for (const [representation, tokens] of Object.entries(runtimeRepresentationPaths ?? {})) {
+		const staticTokens = new Set(staticPaths?.[representation]);
+		for (const token of tokens ?? []) if (runtimePathSet.has(expandPathToken(pathPrefix, token)) || staticTokens.has(token)) return null;
+	}
+	return key === cacheabilityManifestRouteKey(parsed.kind, parsed.pattern) ? parsed : null;
+}
+function parseCacheabilityManifest(value, expectedBuildId) {
+	if (!value || !expectedBuildId) return null;
+	try {
+		const parsed = JSON.parse(value);
+		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+		const record = parsed;
+		if (record.version !== 1 || record.buildId !== expectedBuildId || !record.routes || typeof record.routes !== "object" || Array.isArray(record.routes)) return null;
+		const routes = {};
+		for (const [key, routeValue] of Object.entries(record.routes)) {
+			const route = parseRoute(key, routeValue);
+			if (!route) return null;
+			routes[key] = route;
+		}
+		return {
+			buildId: expectedBuildId,
+			routes,
+			version: 1
+		};
+	} catch {
+		return null;
+	}
+}
+const CONTEXTUAL_RSC_HEADERS = [
+	NEXT_ROUTER_STATE_TREE_HEADER,
+	NEXT_URL_HEADER,
+	VINEXT_INTERCEPTION_CONTEXT_HEADER,
+	VINEXT_INTERCEPTION_ID_HEADER,
+	VINEXT_MOUNTED_SLOTS_HEADER,
+	VINEXT_RSC_STATE_FINGERPRINT_HEADER
+];
+function cacheabilityRequestIdentity(request, trustedRepresentation) {
+	if (request.method !== "GET" && request.method !== "HEAD") return null;
+	if (request.headers.has("next-action") || request.headers.has("x-rsc-action")) return null;
+	const url = new URL(request.url);
+	const requestKey = `${url.pathname}${url.search}`;
+	if (trustedRepresentation) return {
+		representation: trustedRepresentation,
+		requestKey
+	};
+	if (/(?:^|\/)_next\/data\/[^/]+\/.+\.json$/.test(url.pathname)) return {
+		representation: "pages-data",
+		requestKey
+	};
+	if (!(request.headers.get("RSC") === "1" || url.pathname.endsWith(".rsc"))) return (request.headers.get("Accept")?.toLowerCase() ?? "").includes("text/html") ? {
+		representation: "html",
+		requestKey
+	} : {
+		representation: "app-route",
+		requestKey
+	};
+	if (CONTEXTUAL_RSC_HEADERS.some((header) => request.headers.has(header))) return null;
+	const renderMode = request.headers.get(VINEXT_RSC_RENDER_MODE_HEADER);
+	if (renderMode === "prefetch-loading-shell") {
+		if (request.headers.get("Next-Router-Prefetch") !== "1" || request.headers.get("Next-Router-Segment-Prefetch") !== "1") return null;
+		return {
+			representation: "rsc-loading-shell",
+			requestKey
+		};
+	}
+	if (renderMode !== null || request.headers.has("Next-Router-Prefetch") || request.headers.has("Next-Router-Segment-Prefetch")) return null;
+	return {
+		representation: "rsc-full",
+		requestKey
+	};
+}
+function normalizeCacheabilityRoutePathname(pathname) {
+	const normalized = new URL(pathname, "http://vinext.local").pathname;
+	return normalized.length > 1 && normalized.endsWith("/") ? normalized.slice(0, -1) : normalized;
+}
+function cacheabilityRoutePathname(pathname, representation) {
+	const normalized = new URL(pathname, "http://vinext.local").pathname;
+	if (representation === "rsc-full" || representation === "rsc-loading-shell") return normalizeCacheabilityRoutePathname(normalized.endsWith(".rsc") ? normalized.slice(0, -4) : normalized);
+	if (representation !== "pages-data") return normalizeCacheabilityRoutePathname(normalized);
+	const marker = normalized.indexOf("/_next/data/");
+	const restWithBuildId = marker === -1 ? "" : normalized.slice(marker + 12);
+	const buildIdEnd = restWithBuildId.indexOf("/");
+	if (buildIdEnd === -1 || !restWithBuildId.endsWith(".json")) return normalizeCacheabilityRoutePathname(normalized);
+	const assetPath = restWithBuildId.slice(buildIdEnd + 1, -5);
+	if (!assetPath) return normalizeCacheabilityRoutePathname(normalized);
+	let pagePathname;
+	if (assetPath === "index") pagePathname = "/";
+	else if (assetPath.endsWith("/index")) pagePathname = `/${assetPath.slice(0, -6)}`;
+	else if (assetPath.startsWith("index/")) pagePathname = `/${assetPath.slice(6)}`;
+	else pagePathname = `/${assetPath}`;
+	const basePath = normalized.slice(0, marker);
+	return normalizeCacheabilityRoutePathname(pagePathname === "/" ? basePath || "/" : `${basePath}${pagePathname}`);
+}
+function cacheabilityManifestRouteState(route, routePathname, representation) {
+	const pathname = normalizeCacheabilityRoutePathname(routePathname);
+	let pathToken = pathname;
+	if (route.pathPrefix !== void 0) {
+		if (!pathname.startsWith(route.pathPrefix) || !route.pathPrefix.endsWith("/") && pathname.length > route.pathPrefix.length && pathname[route.pathPrefix.length] !== "/") return route.allowUnknown === true ? route.unknownState ?? route.state : null;
+		pathToken = pathname.slice(route.pathPrefix.length);
+	}
+	const includesPath = (paths) => {
+		if (!paths) return false;
+		let low = 0;
+		let high = paths.length - 1;
+		while (low <= high) {
+			const middle = low + high >>> 1;
+			const candidate = paths[middle];
+			if (candidate === pathToken) return true;
+			if (candidate < pathToken) low = middle + 1;
+			else high = middle - 1;
+		}
+		return false;
+	};
+	if (representation && includesPath(route.staticPaths?.[representation])) return "static-candidate";
+	if (representation && route.staticRepresentation === representation) return "static-candidate";
+	if (route.runtimeRepresentation !== void 0) return representation === route.runtimeRepresentation ? route.state : null;
+	if (representation && includesPath(route.runtimeRepresentationPaths?.[representation])) return route.state;
+	if (!route.staticPaths && !route.runtimePaths && !route.runtimeRepresentationPaths && route.allowUnknown !== true) return route.state;
+	if (includesPath(route.runtimePaths)) return route.state;
+	if (route.staticPaths) {
+		for (const paths of Object.values(route.staticPaths)) if (includesPath(paths)) return route.state;
+	}
+	if (route.allowUnknown === true) return route.unknownState ?? route.state;
+	return null;
+}
+function findCacheabilityManifestRoute(manifest, kind, pattern) {
+	return manifest.routes[cacheabilityManifestRouteKey(kind, pattern)] ?? null;
+}
+function resolveCacheabilityRepresentation(representation, routeKind) {
+	if (representation !== "html" && representation !== "app-route") return representation;
+	return routeKind === "app-route" || routeKind === "pages-api" ? "app-route" : "html";
+}
+/** Whether completed-response admission can store a page route under this representation. */
+function cacheabilityRepresentationMatchesPageRoute(routeKind, representation) {
+	return routeKind === "app-page" ? representation === "html" || representation === "rsc-full" || representation === "rsc-loading-shell" : representation === "html" || representation === "pages-data";
+}
+/**
+* The manifest state completed-response admission gives a page request, or
+* null when admission refuses it. `requestRepresentation` is the request
+* identity's, and `routePathname` is built from the resolved pathname with
+* `cacheabilityRoutePathname`, as admission builds it. The Workers Cache
+* request stage decides its query-free dispatch with this same function, so
+* the dispatch and admission always see the same state.
+*/
+function cacheabilityManifestPageState(manifest, route, requestRepresentation, routePathname) {
+	const representation = resolveCacheabilityRepresentation(requestRepresentation, route.kind);
+	if (!cacheabilityRepresentationMatchesPageRoute(route.kind, representation)) return null;
+	const manifestRoute = findCacheabilityManifestRoute(manifest, route.kind, route.pattern);
+	return manifestRoute ? cacheabilityManifestRouteState(manifestRoute, routePathname, representation) : null;
+}
+/** Whether any path or representation of a route can resolve to `static-candidate`. */
+function canResolveStaticCandidate(route) {
+	return route.state === "static-candidate" || route.unknownState === "static-candidate" || route.staticRepresentation !== void 0 || route.staticPaths !== void 0;
+}
+/**
+* Project the manifest onto the Workers Cache request stage, which strips the
+* query from App page dispatches whose manifest state is `static-candidate`.
+* The projection keeps every App page route record that can resolve to that
+* state, unchanged, so a lookup against it returns `static-candidate` exactly
+* when the full manifest does. Every other route is left out.
+*/
+function projectCacheabilityManifestForRequestStage(manifest) {
+	return {
+		buildId: manifest.buildId,
+		routes: Object.fromEntries(Object.entries(manifest.routes).filter(([, route]) => route.kind === "app-page" && canResolveStaticCandidate(route))),
+		version: 1
+	};
+}
+//#endregion
+export { CACHEABILITY_MANIFEST_MODULE, CACHEABILITY_REQUEST_PROJECTION_MODULE, cacheabilityManifestPageState, cacheabilityManifestRouteKey, cacheabilityManifestRouteState, cacheabilityRepresentationMatchesPageRoute, cacheabilityRequestIdentity, cacheabilityRoutePathname, findCacheabilityManifestRoute, normalizeCacheabilityRoutePathname, parseCacheabilityManifest, projectCacheabilityManifestForRequestStage, resolveCacheabilityRepresentation };

package/dist/server/cacheability-request.d.ts

@@ -0,0 +1,49 @@
+import { CacheabilityRepresentation, CacheabilityRouteKind } from "./cacheability-manifest.js";
+import { ExecutionContextLike } from "../shims/request-context.js";
+//#region src/server/cacheability-request.d.ts
+export type WorkerCacheabilityProbeMode = "identity" | "probe";
+export type WorkerCacheabilityProbeRoute = {
+  kind: CacheabilityRouteKind;
+  pattern: string;
+};
+/** Encode the trusted route identity carried by a staged probe request. */
+export declare function serializeWorkerCacheabilityProbeRoute(route: WorkerCacheabilityProbeRoute): string;
+/** Read route identity only after the surrounding probe request is authenticated. */
+export declare function readWorkerCacheabilityProbeRoute(request: Request): WorkerCacheabilityProbeRoute | null;
+/** Authenticate and read the cacheability probe mode before internal headers are filtered. */
+export declare function readWorkerCacheabilityProbeMode(request: Request, expectedSecret: string | null | undefined): WorkerCacheabilityProbeMode | null;
+/** Create probe state from a mode that was authenticated at the request boundary. */
+export declare function createWorkerCacheabilityProbeContext(base: ExecutionContextLike, mode: WorkerCacheabilityProbeMode, responseVary?: "verbatim", resolvedRoutePathname?: string): ExecutionContextLike;
+export declare function createWorkerCacheabilityContext(base: ExecutionContextLike, request: Request, expectedSecret: string | null | undefined, responseVary?: "verbatim"): ExecutionContextLike;
+export declare function createWorkerCacheabilityAdmissionContext(base: ExecutionContextLike, request: Request, rawManifest: string | null | undefined, buildId: string | null | undefined, requiresCompletedResponseAdmission?: boolean, responseVary?: "verbatim", resolvedRoutePathname?: string, trustedRepresentation?: CacheabilityRepresentation, options?: {
+  applyCompletedResponsePolicy?: boolean;
+}): ExecutionContextLike;
+/** Apply request-stage-vetted positive config policy inside the admission boundary. */
+export declare function applyResponseStageCachePolicy(response: Response, ctx: ExecutionContextLike, policyHeaders: ReadonlyArray<readonly [string, string]> | null | undefined): Response;
+/** Record policy that a renderer applied before producing its response. */
+export declare function recordResponseStageCachePolicy(ctx: ExecutionContextLike, policyHeaders: ReadonlyArray<readonly [string, string]> | null | undefined): void;
+/**
+ * Convert an authenticated probe that terminated in request routing into a
+ * valid identity-scoped dynamic result. Middleware redirects, custom responses,
+ * and external rewrites never reach the reusable response stage.
+ */
+export declare function finalizeRequestStageCacheabilityProbe(response: Response, options: {
+  mode: WorkerCacheabilityProbeMode | null;
+  responseStageDispatched: boolean;
+  route: WorkerCacheabilityProbeRoute | null;
+}): Response;
+type CapturedAdmissionBody = {
+  body: ReadableStream<Uint8Array> | null;
+  kind: "captured";
+} | {
+  body: ReadableStream<Uint8Array>;
+  kind: "fallback";
+};
+export type CacheabilityAdmissionCaptureBudget = {
+  maxBytes: number;
+  reservedBytes: number;
+};
+export declare function createCacheabilityAdmissionCaptureBudget(maxBytes: number): CacheabilityAdmissionCaptureBudget;
+export declare function captureCacheabilityAdmissionBody(body: ReadableStream<Uint8Array> | null, deadlineAt: number, limit?: number, budget?: CacheabilityAdmissionCaptureBudget): Promise<CapturedAdmissionBody>;
+export declare function finalizeWorkerCacheabilityResponse(response: Response, ctx: ExecutionContextLike): Promise<Response>;
+//#endregion