vinext 1.3.0 → 1.4.0

package/dist/server/app-streamed-client-references.js

@@ -0,0 +1,156 @@
+import { getOrCreateAls } from "../shims/internal/als-registry.js";
+import { escapeHtmlAttr } from "./html.js";
+import * as ReactDOM from "react-dom";
+import { setOnClientReference } from "@vitejs/plugin-rsc/ssr";
+//#region src/server/app-streamed-client-references.ts
+/**
+* Stream the client references an SSR render may show before they load, and
+* link every client reference's scripts with the render's CSP nonce and the
+* configured crossOrigin, and its stylesheets with the configured crossOrigin.
+*
+* A render waits for its route's client references before it starts, except
+* those whose modules evaluate asynchronously (top-level await). Like Next.js,
+* it streams those: React suspends on one until it loads, showing the nearest
+* Suspense fallback first.
+*
+* plugin-rsc links a client module's stylesheets as the render reads its
+* exports, so a streamed module would link them wherever it rendered once
+* loaded, which depends on how long it took. Instead, a render links a
+* streamed reference's stylesheets in the route's import order, as Next.js's
+* Turbopack build does: just before the first reference after it links its
+* own, or after the shell's stylesheets when none does. Its scripts link as the
+* Flight stream names it.
+*
+* plugin-rsc hints a client module's scripts without the render's nonce, which
+* a nonce-based CSP blocks, and always as anonymous, so under
+* `crossOrigin: "use-credentials"` the browser fetches the module the page
+* then imports without credentials. React keeps the first hint for each
+* script, so a render with either hints them first, with both, as Next.js does.
+* plugin-rsc also links its stylesheets as anonymous whatever the config, so a
+* render links them first with the configured crossOrigin too. Unlike Next.js,
+* it links them as anonymous when that's unset: Vite's preload helper always
+* links a lazily imported module's stylesheets as anonymous, and a later page
+* doing so would fail the CORS check on the no-cors copy the browser cached.
+*/
+const WRAPPED = Symbol.for("vinext.streamedClientReferences.wrapped");
+const STYLESHEET_PRECEDENCE = "vite-rsc/client-reference";
+const referenceDeps = /* @__PURE__ */ new Map();
+const renderStorage = getOrCreateAls("vinext.streamedClientReferences");
+function hintsScripts(render) {
+	return !!render.nonce || render.crossOrigin === "use-credentials";
+}
+function linkScripts(deps, render) {
+	const options = {
+		as: "script",
+		crossOrigin: render.crossOrigin,
+		fetchPriority: "low",
+		nonce: render.nonce
+	};
+	for (const href of deps.js) ReactDOM.preloadModule(href, options);
+}
+function linkStylesheets(hrefs, render) {
+	const options = {
+		as: "style",
+		crossOrigin: render.crossOrigin,
+		precedence: STYLESHEET_PRECEDENCE
+	};
+	for (const href of hrefs) ReactDOM.preinit(href, options);
+}
+/**
+* Before reference `id` links its stylesheets, link those of the streamed
+* references that come before it in import order.
+*/
+function linkStreamedStylesheetsBefore(render, id) {
+	const position = render.positions.get(id);
+	if (position === void 0) return;
+	while (render.unlinked.length > 0 && render.positions.get(render.unlinked[0]) < position) {
+		const hrefs = referenceDeps.get(render.unlinked.shift())?.css ?? [];
+		for (const href of hrefs) render.linkedStylesheets.add(href);
+		linkStylesheets(hrefs, render);
+	}
+}
+/**
+* Wrap plugin-rsc's client-reference loader before any client reference
+* loads; a production build calls this as its SSR entry starts. `asyncIds` are
+* the references any route may stream, and `getLoader` returns a reference's
+* own loader from the client-references module.
+*/
+function wrapClientReferenceRequire(asyncIds, getLoader) {
+	const load = globalThis.__vite_rsc_client_require__;
+	if (typeof load !== "function" || WRAPPED in load) return;
+	setOnClientReference(({ id, deps }) => {
+		referenceDeps.set(id, deps);
+		const render = renderStorage.getStore();
+		if (render && !render.streamed.has(id)) for (const href of deps.css) render.linkedStylesheets.add(href);
+	});
+	const loads = /* @__PURE__ */ new Map();
+	const wrapped = (id) => {
+		const render = renderStorage.getStore();
+		if (render?.streamed.has(id)) {
+			const deps = referenceDeps.get(id);
+			if (deps) linkScripts(deps, render);
+		}
+		let loading = loads.get(id);
+		if (!loading) {
+			const loader = asyncIds.has(id) ? getLoader(id) : void 0;
+			loading = Promise.all([load(id), loader?.()]).then(([mod, exports]) => new Proxy(mod, { get(target, key, receiver) {
+				const render = renderStorage.getStore();
+				if (render) {
+					if (exports !== void 0 && render.streamed.has(id)) return Reflect.get(exports, key);
+					linkStreamedStylesheetsBefore(render, id);
+					const deps = referenceDeps.get(id);
+					if (deps && key in target) {
+						linkStylesheets(deps.css, render);
+						if (hintsScripts(render)) linkScripts(deps, render);
+					}
+				}
+				return Reflect.get(target, key, receiver);
+			} }));
+			loads.set(id, loading);
+		}
+		return loading;
+	};
+	Object.defineProperty(wrapped, WRAPPED, { value: true });
+	globalThis.__vite_rsc_client_require__ = wrapped;
+}
+function createStreamedClientReferences(route, nonce, crossOrigin) {
+	const streamed = new Set(route?.streamed);
+	return {
+		nonce,
+		crossOrigin,
+		streamed,
+		positions: new Map(route?.references.map((id, index) => [id, index])),
+		unlinked: route?.references.filter((id) => streamed.has(id)) ?? [],
+		linkedStylesheets: /* @__PURE__ */ new Set()
+	};
+}
+/**
+* Forget the stylesheets a discarded render linked, so the render that
+* replaces it links them again.
+*/
+function resetStreamedClientReferences(render, route) {
+	if (!render) return;
+	render.unlinked = route?.references.filter((id) => render.streamed.has(id)) ?? [];
+	render.linkedStylesheets.clear();
+}
+/** Run a render, and the Flight stream it reads, with its streamed references. */
+function runWithStreamedClientReferences(render, fn) {
+	return renderStorage.run(render, fn);
+}
+/**
+* The `<head>` links of the streamed stylesheets a render's shell left
+* unlinked, those of streamed references after every reference it rendered.
+*/
+function renderStreamedStylesheets(render) {
+	const hrefs = /* @__PURE__ */ new Set();
+	for (const id of render.unlinked.splice(0)) for (const href of referenceDeps.get(id)?.css ?? []) if (!render.linkedStylesheets.has(href)) hrefs.add(href);
+	const crossOrigin = render.crossOrigin === "use-credentials" ? "use-credentials" : "";
+	let html = "";
+	for (const href of hrefs) {
+		render.linkedStylesheets.add(href);
+		html += `<link rel="stylesheet" href="${escapeHtmlAttr(href)}" data-precedence="${STYLESHEET_PRECEDENCE}" crossorigin="${crossOrigin}"/>`;
+	}
+	return html;
+}
+//#endregion
+export { createStreamedClientReferences, renderStreamedStylesheets, resetStreamedClientReferences, runWithStreamedClientReferences, wrapClientReferenceRequire };

package/dist/server/app-visited-response-cache.d.ts

@@ -7,7 +7,17 @@ export type VisitedResponseCacheEntry = {
   createdAt: number;
   elements?: AppElements;
   expiresAt: number;
+  /**
+   * Stored by initial hydration, which Next.js keeps out of its route cache
+   * (outside Cache Components), so a visible Link still prefetches the URL.
+   */
+  fromHydration?: true;
   mountedSlotsHeader: string | null;
+  /**
+   * A history restore revoked navigation reuse. The entry stays only as the
+   * BFCache that a full prefetch reads (see `findVisitedResponseForFullPrefetch`).
+   */
+  navigationReuseRevoked?: true;
   params: Record<string, string | string[]>;
   response: CachedRscResponse;
   reuseAfterHistoryRestore: boolean;
@@ -18,6 +28,7 @@ export declare function hasNavigationResponseHistoryLifetime(snapshot: CachedRsc
 export declare function createVisitedResponseCacheEntry(options: {
   elements?: AppElements;
   fallbackTtlMs?: number;
+  fromHydration?: boolean;
   now: number;
   mountedSlotsHeader?: string | null;
   params: Record<string, string | string[]>;
@@ -34,5 +45,30 @@ export declare function findVisitedResponseCacheEntry(cache: Map<string, Visited
 } | null;
 export declare function deleteVisitedResponseCacheEntry(cache: Map<string, VisitedResponseCacheEntry>, rscUrl: string, interceptionContext: string | null): boolean;
 export declare function deleteAllVisitedResponseCacheEntries(cache: Map<string, VisitedResponseCacheEntry>, rscUrl: string, interceptionContext: string | null): number;
-export declare function deleteInvalidatedHistoryRestoreEntries(cache: Map<string, VisitedResponseCacheEntry>): void;
-//#endregion
+export declare function revokeHistoryRestoreNavigationReuse(cache: Map<string, VisitedResponseCacheEntry>): void;
+/**
+ * Next.js fulfills a full prefetch from the BFCache, which holds the data of
+ * every navigation, while it is within the static stale time of that
+ * navigation (`attemptToFulfillDynamicSegmentFromBFCache`). Navigation reuse
+ * that a history restore revoked does not matter here.
+ *
+ * Next.js dates a BFCache entry from its navigation, even one that committed an
+ * older prefetched payload. Its re-prefetch of an expired route still waits for
+ * a fresh route tree first, so a navigation made then fetches fresh data
+ * (`client-cache.experimental.test.ts`, "re-use the cache for 5 minutes").
+ * vinext seeds the full prefetch synchronously, so dating it from the
+ * navigation would replay that expired payload. It dates from when the payload
+ * arrived instead, which only costs a request Next.js might have saved.
+ *
+ * The match follows direct visited reuse: an entry with committed elements
+ * replays them, because its raw response may be skip-pruned against the tree
+ * it was requested from; otherwise the request-time or response-declared slot
+ * context must match.
+ */
+export declare function findVisitedResponseForFullPrefetch(cache: Map<string, VisitedResponseCacheEntry>, rscUrls: readonly string[], interceptionContext: string | null, mountedSlotsHeader: string | null): {
+  navigatedAt: number;
+  navigationFreshUntil: number | null;
+  response: CachedRscResponse;
+} | null;
+//#endregion
+export {};

package/dist/server/app-visited-response-cache.js

@@ -1,6 +1,6 @@
+import { parseRscRequestPath, stripRscCacheBustingSearchParam } from "./app-rsc-cache-busting.js";
 import { AppElementsWire } from "./app-elements-wire.js";
 import "./app-elements.js";
-import { parseRscRequestPath, stripRscCacheBustingSearchParam } from "./app-rsc-cache-busting.js";
 import { resolveCachedRscResponseExpiresAt } from "../shims/navigation.js";
 //#region src/server/app-visited-response-cache.ts
 const VISITED_RESPONSE_CACHE_TTL = 3e5;
@@ -14,6 +14,7 @@ function createVisitedResponseCacheEntry(options) {
 		createdAt: options.now,
 		...options.elements ? { elements: options.elements } : {},
 		expiresAt: resolveCachedRscResponseExpiresAt(options.now, options.response, options.fallbackTtlMs ?? 3e5),
+		...options.fromHydration === true ? { fromHydration: true } : {},
 		mountedSlotsHeader: options.mountedSlotsHeader ?? null,
 		params: options.params,
 		response: options.response,
@@ -75,11 +76,51 @@ function deleteAllVisitedResponseCacheEntries(cache, rscUrl, interceptionContext
 	while (deleteVisitedResponseCacheEntry(cache, rscUrl, interceptionContext)) deleted++;
 	return deleted;
 }
-function deleteInvalidatedHistoryRestoreEntries(cache) {
-	for (const [cacheKey, entry] of cache) {
+function revokeHistoryRestoreNavigationReuse(cache) {
+	for (const entry of cache.values()) {
 		if (entry.reuseAfterHistoryRestore) continue;
-		cache.delete(cacheKey);
+		entry.navigationReuseRevoked = true;
+	}
+}
+/**
+* Next.js fulfills a full prefetch from the BFCache, which holds the data of
+* every navigation, while it is within the static stale time of that
+* navigation (`attemptToFulfillDynamicSegmentFromBFCache`). Navigation reuse
+* that a history restore revoked does not matter here.
+*
+* Next.js dates a BFCache entry from its navigation, even one that committed an
+* older prefetched payload. Its re-prefetch of an expired route still waits for
+* a fresh route tree first, so a navigation made then fetches fresh data
+* (`client-cache.experimental.test.ts`, "re-use the cache for 5 minutes").
+* vinext seeds the full prefetch synchronously, so dating it from the
+* navigation would replay that expired payload. It dates from when the payload
+* arrived instead, which only costs a request Next.js might have saved.
+*
+* The match follows direct visited reuse: an entry with committed elements
+* replays them, because its raw response may be skip-pruned against the tree
+* it was requested from; otherwise the request-time or response-declared slot
+* context must match.
+*/
+function findVisitedResponseForFullPrefetch(cache, rscUrls, interceptionContext, mountedSlotsHeader) {
+	for (const rscUrl of rscUrls) {
+		const match = findVisitedResponseCacheEntry(cache, rscUrl, interceptionContext);
+		if (match === null) continue;
+		const { entry } = match;
+		if (entry.elements === void 0 && entry.mountedSlotsHeader !== mountedSlotsHeader && (entry.response.mountedSlotsHeader ?? null) !== mountedSlotsHeader) continue;
+		const navigationFresh = entry.fromHydration !== true && entry.navigationReuseRevoked !== true && (entry.elements !== void 0 || entry.mountedSlotsHeader === mountedSlotsHeader) && isVisitedResponseCacheEntryFresh(entry, {
+			navigationKind: "navigate",
+			now: Date.now()
+		});
+		return {
+			navigatedAt: entry.response.receivedAt ?? entry.createdAt,
+			navigationFreshUntil: navigationFresh ? entry.expiresAt : null,
+			response: entry.elements === void 0 ? entry.response : {
+				...entry.response,
+				preparedElements: entry.elements
+			}
+		};
 	}
+	return null;
 }
 //#endregion
-export { MAX_TRAVERSAL_CACHE_TTL, VISITED_RESPONSE_CACHE_TTL, createVisitedResponseCacheEntry, deleteAllVisitedResponseCacheEntries, deleteInvalidatedHistoryRestoreEntries, deleteVisitedResponseCacheEntry, findVisitedResponseCacheEntry, hasNavigationResponseHistoryLifetime, isVisitedResponseCacheEntryFresh };
+export { MAX_TRAVERSAL_CACHE_TTL, VISITED_RESPONSE_CACHE_TTL, createVisitedResponseCacheEntry, deleteAllVisitedResponseCacheEntries, deleteVisitedResponseCacheEntry, findVisitedResponseCacheEntry, findVisitedResponseForFullPrefetch, hasNavigationResponseHistoryLifetime, isVisitedResponseCacheEntryFresh, revokeHistoryRestoreNavigationReuse };

package/dist/server/app-worker-stages.d.ts

@@ -3,7 +3,7 @@ import { VinextResponseStageCacheability, VinextResponseStageDispatchOptions, Vi
 import { AppRscRenderMode } from "./app-rsc-render-mode.js";
 import { TrustedPrerenderState } from "./prerender-route-params.js";
 //#region src/server/app-worker-stages.d.ts
-export declare const APP_WORKER_RESPONSE_STAGE_PROTOCOL_VERSION = 11;
+export declare const APP_WORKER_RESPONSE_STAGE_PROTOCOL_VERSION = 13;
 export declare const APP_METADATA_RESPONSE_STAGE_NO_MATCH_HEADER = "x-vinext-app-metadata-stage-no-match";
 type AppPageParams = Record<string, string | string[]>;
 type AppWorkerResponseStageEnvelope = {
@@ -66,7 +66,7 @@ type AppMetadataWorkerResponseStageProps = AppWorkerResponseStageEnvelope & {
   resolvedUrl: string;
   routePathname: string;
 };
-type HybridPagesWorkerResponseStageProps = AppWorkerResponseStageEnvelope & {
+export type HybridPagesWorkerResponseStageProps = AppWorkerResponseStageEnvelope & {
   kind: "hybrid-pages";
   allowRscDocumentFallback: boolean;
   appRouteMatch: {
@@ -83,19 +83,41 @@ type HybridPagesWorkerResponseStageProps = AppWorkerResponseStageEnvelope & {
   resourceKind: "api" | "page";
   requestUrl: string;
   resolvedUrl: string;
+  /**
+   * The shared cache entry answers every host, as Next.js keys a static page
+   * by its path, so a getInitialProps render of a page without
+   * getStaticProps, which reads the request, is not stored.
+   */
+  sharedAcrossHosts: boolean;
 };
 export type AppWorkerResponseStageProps = AppFullRequestWorkerResponseStageProps | AppMatchedWorkerResponseStageProps | AppMetadataWorkerResponseStageProps | AppNotFoundWorkerResponseStageProps | HybridPagesWorkerResponseStageProps;
 export type DispatchAppWorkerResponseStage = VinextResponseStageTransport<AppWorkerResponseStageProps>;
 export type RenderAppWorkerResponseStageLocally = (request: Request, props: AppWorkerResponseStageProps) => Promise<Response>;
 /** Normalize a shared App page HEAD request onto its method-invariant GET representation. */
 export declare function prepareSharedAppPageDispatch(request: Request, cache: VinextResponseStageDispatchOptions["cache"]): Request;
+type SharedAppCacheIdentity = NonNullable<VinextResponseStageDispatchOptions["cacheIdentity"]>;
+/** App Router dispatches whose shared cache entry every host can reuse. */
+export type SharedAppCacheIdentityProps = Exclude<AppWorkerResponseStageProps, {
+  kind: "app-full-request" | "hybrid-pages";
+}>;
+/**
+ * Build the cache identity of a shared App Router dispatch: the dispatched
+ * request and props under the cache identity origin.
+ */
+export declare function createSharedAppCacheIdentity(request: Request, props: SharedAppCacheIdentityProps): SharedAppCacheIdentity;
 /**
  * Build the query-free cache identity of a shared App page dispatch. The user
  * query leaves both the URL and `resolvedUrl`; the `.rsc` suffix, an RSC
  * request's validated `_rsc`, and the render mode stay because they select the
  * representation. HTML identities also drop the RSC selector headers.
  */
-export declare function createSharedAppPageCacheIdentity(request: Request, props: AppMatchedWorkerResponseStageProps): NonNullable<VinextResponseStageDispatchOptions["cacheIdentity"]>;
+export declare function createSharedAppPageCacheIdentity(request: Request, props: AppMatchedWorkerResponseStageProps): SharedAppCacheIdentity;
+/**
+ * Build the cache identity of a shared hybrid Pages page dispatch: the
+ * dispatched request and props under `origin`, so every host that names it
+ * shares one entry.
+ */
+export declare function createSharedHybridPagesCacheIdentity(request: Request, props: HybridPagesWorkerResponseStageProps, origin: string): SharedAppCacheIdentity;
 /**
  * Drop the user query from an App page dispatch URL and its `resolvedUrl`,
  * keeping an RSC request's validated `_rsc`, the rule the query-free cache
@@ -114,4 +136,5 @@ export declare function withoutAppPageDispatchQuery(requestUrl: string, props: A
  */
 export declare function isStaticCandidateAppPageDispatch(projection: CacheabilityManifest, request: Request, props: AppMatchedWorkerResponseStageProps): boolean;
 export declare function isAppWorkerResponseStageProps(value: unknown): value is AppWorkerResponseStageProps;
-//#endregion
+//#endregion
+export {};

package/dist/server/app-worker-stages.js

@@ -2,14 +2,34 @@ import { VINEXT_RSC_VARY_HEADER } from "./app-rsc-vary.js";
 import { cacheabilityManifestPageState, cacheabilityRequestIdentity, cacheabilityRoutePathname } from "./cacheability-manifest.js";
 import { keepOnlyValidatedRscCacheBustingSearchParam } from "./app-rsc-cache-busting.js";
 import { isTrustedPrerenderState } from "./prerender-route-params.js";
+import { VINEXT_CACHE_IDENTITY_ORIGIN, withCacheIdentityOrigin } from "./multi-stage.js";
 //#region src/server/app-worker-stages.ts
-const APP_WORKER_RESPONSE_STAGE_PROTOCOL_VERSION = 11;
+const APP_WORKER_RESPONSE_STAGE_PROTOCOL_VERSION = 13;
 const APP_METADATA_RESPONSE_STAGE_NO_MATCH_HEADER = "x-vinext-app-metadata-stage-no-match";
 const STATIC_FILE_SIGNAL_TOKEN_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
 /** Normalize a shared App page HEAD request onto its method-invariant GET representation. */
 function prepareSharedAppPageDispatch(request, cache) {
 	return cache !== "bypass" && request.method.toUpperCase() === "HEAD" ? new Request(request, { method: "GET" }) : request;
 }
+function sharedAppCacheIdentity(requestUrl, init, props) {
+	return {
+		props: {
+			...props,
+			requestOrigin: VINEXT_CACHE_IDENTITY_ORIGIN
+		},
+		request: new Request(withCacheIdentityOrigin(requestUrl), init)
+	};
+}
+/**
+* Build the cache identity of a shared App Router dispatch: the dispatched
+* request and props under the cache identity origin.
+*/
+function createSharedAppCacheIdentity(request, props) {
+	return sharedAppCacheIdentity(request.url, {
+		headers: new Headers(request.headers),
+		method: request.method
+	}, props);
+}
 /**
 * Build the query-free cache identity of a shared App page dispatch. The user
 * query leaves both the URL and `resolvedUrl`; the `.rsc` suffix, an RSC
@@ -21,10 +41,29 @@ function createSharedAppPageCacheIdentity(request, props) {
 	const headers = new Headers(request.headers);
 	if (!props.isRscRequest) for (const name of VINEXT_RSC_VARY_HEADER.split(",")) headers.delete(name.trim());
 	return {
-		props: queryFree.props,
-		request: new Request(queryFree.url, {
+		...sharedAppCacheIdentity(queryFree.url, {
 			headers,
 			method: request.method
+		}, queryFree.props),
+		queryFree: true
+	};
+}
+/**
+* Build the cache identity of a shared hybrid Pages page dispatch: the
+* dispatched request and props under `origin`, so every host that names it
+* shares one entry.
+*/
+function createSharedHybridPagesCacheIdentity(request, props, origin) {
+	return {
+		props: {
+			...props,
+			requestOrigin: origin,
+			requestUrl: withCacheIdentityOrigin(props.requestUrl, origin)
+		},
+		regenerateFromDispatch: true,
+		request: new Request(withCacheIdentityOrigin(request.url, origin), {
+			headers: new Headers(request.headers),
+			method: request.method
 		})
 	};
 }
@@ -80,12 +119,12 @@ function isCanonicalHttpOrigin(value) {
 function isAppWorkerResponseStageProps(value) {
 	if (!value || typeof value !== "object") return false;
 	const props = value;
-	if (props.protocolVersion !== 11 || props.buildId !== null && typeof props.buildId !== "string" || !isResponseStageCacheability(props.cacheability) || props.draftModeCookie !== null && typeof props.draftModeCookie !== "string" || props.middlewareCookieOverlay !== null && typeof props.middlewareCookieOverlay !== "string" || !isCanonicalHttpOrigin(props.requestOrigin) || props.scriptNonce !== null && typeof props.scriptNonce !== "string") return false;
+	if (props.protocolVersion !== 13 || props.buildId !== null && typeof props.buildId !== "string" || !isResponseStageCacheability(props.cacheability) || props.draftModeCookie !== null && typeof props.draftModeCookie !== "string" || props.middlewareCookieOverlay !== null && typeof props.middlewareCookieOverlay !== "string" || !isCanonicalHttpOrigin(props.requestOrigin) || props.scriptNonce !== null && typeof props.scriptNonce !== "string") return false;
 	if (props.kind === "app-full-request") return typeof props.headRequest === "boolean" && typeof props.prerenderDiscovery === "boolean" && typeof props.staticFileSignalToken === "string" && STATIC_FILE_SIGNAL_TOKEN_RE.test(props.staticFileSignalToken) && (props.trustedPrerenderState === null || isTrustedPrerenderState(props.trustedPrerenderState));
 	if (props.kind === "hybrid-pages") {
 		const hybrid = props;
 		const appRouteMatch = hybrid.appRouteMatch;
-		return typeof hybrid.allowRscDocumentFallback === "boolean" && (appRouteMatch === null || typeof appRouteMatch === "object" && typeof appRouteMatch.isDynamic === "boolean" && typeof appRouteMatch.pattern === "string" && appRouteMatch.pattern.startsWith("/")) && typeof hybrid.canonicalPathname === "string" && hybrid.canonicalPathname.startsWith("/") && typeof hybrid.cleanPathname === "string" && hybrid.cleanPathname.startsWith("/") && typeof hybrid.isDataRequest === "boolean" && typeof hybrid.isRscRequest === "boolean" && (hybrid.matchKind === "dynamic" || hybrid.matchKind === "static") && (hybrid.preHandlerHeaders === null || isSerializedHeaders(hybrid.preHandlerHeaders)) && (hybrid.resourceKind === "api" || hybrid.resourceKind === "page") && typeof hybrid.requestUrl === "string" && typeof hybrid.resolvedUrl === "string" && hybrid.resolvedUrl.startsWith("/");
+		return typeof hybrid.allowRscDocumentFallback === "boolean" && (appRouteMatch === null || typeof appRouteMatch === "object" && typeof appRouteMatch.isDynamic === "boolean" && typeof appRouteMatch.pattern === "string" && appRouteMatch.pattern.startsWith("/")) && typeof hybrid.canonicalPathname === "string" && hybrid.canonicalPathname.startsWith("/") && typeof hybrid.cleanPathname === "string" && hybrid.cleanPathname.startsWith("/") && typeof hybrid.isDataRequest === "boolean" && typeof hybrid.isRscRequest === "boolean" && (hybrid.matchKind === "dynamic" || hybrid.matchKind === "static") && (hybrid.preHandlerHeaders === null || isSerializedHeaders(hybrid.preHandlerHeaders)) && (hybrid.resourceKind === "api" || hybrid.resourceKind === "page") && typeof hybrid.requestUrl === "string" && typeof hybrid.resolvedUrl === "string" && hybrid.resolvedUrl.startsWith("/") && typeof hybrid.sharedAcrossHosts === "boolean";
 	}
 	if (props.kind === "app-metadata" || props.kind === "app-not-found") {
 		const special = props;
@@ -102,4 +141,4 @@ function isResponseStageCacheability(value) {
 	return (cacheability.probeMode === null || cacheability.probeMode === "probe" || cacheability.probeMode === "identity") && (cacheability.policyHeaders === null || Array.isArray(cacheability.policyHeaders) && cacheability.policyHeaders.every((entry) => Array.isArray(entry) && entry.length === 2 && typeof entry[0] === "string" && typeof entry[1] === "string")) && (cacheability.representation === void 0 || cacheability.representation === "app-route" || cacheability.representation === "html" || cacheability.representation === "pages-data" || cacheability.representation === "rsc-full" || cacheability.representation === "rsc-loading-shell") && typeof cacheability.resolvedRoutePathname === "string" && cacheability.resolvedRoutePathname.startsWith("/");
 }
 //#endregion
-export { APP_METADATA_RESPONSE_STAGE_NO_MATCH_HEADER, APP_WORKER_RESPONSE_STAGE_PROTOCOL_VERSION, createSharedAppPageCacheIdentity, isAppWorkerResponseStageProps, isStaticCandidateAppPageDispatch, prepareSharedAppPageDispatch, withoutAppPageDispatchQuery };
+export { APP_METADATA_RESPONSE_STAGE_NO_MATCH_HEADER, APP_WORKER_RESPONSE_STAGE_PROTOCOL_VERSION, createSharedAppCacheIdentity, createSharedAppPageCacheIdentity, createSharedHybridPagesCacheIdentity, isAppWorkerResponseStageProps, isStaticCandidateAppPageDispatch, prepareSharedAppPageDispatch, withoutAppPageDispatchQuery };

package/dist/server/artifact-compatibility.d.ts

@@ -11,7 +11,6 @@ export type ArtifactCompatibilityEnvelope = Readonly<{
   rootBoundaryId: string | null;
   renderEpoch: string | null;
 }>;
-export declare const ARTIFACT_COMPATIBILITY_PROOF_FIELDS: readonly (keyof ArtifactCompatibilityEnvelope)[];
 type ArtifactCompatibilityEnvelopeInput = Readonly<{
   graphVersion?: string | null;
   deploymentVersion?: string | null;
@@ -50,4 +49,5 @@ export declare function createArtifactCompatibilityEnvelope(input?: ArtifactComp
 export declare function createArtifactCompatibilityGraphVersion(input: ArtifactCompatibilityGraphVersionInput): string;
 export declare function parseArtifactCompatibilityEnvelope(value: unknown): ArtifactCompatibilityEnvelope | null;
 export declare function evaluateArtifactCompatibility(current: ArtifactCompatibilityEnvelope, candidate: ArtifactCompatibilityEnvelope, options?: ArtifactCompatibilityEvaluationOptions): ArtifactCompatibilityDecision;
-//#endregion
+//#endregion
+export {};

package/dist/server/artifact-compatibility.js

@@ -4,15 +4,6 @@ import { fnv1a64 } from "../utils/hash.js";
 const ARTIFACT_COMPATIBILITY_SCHEMA_VERSION = 1;
 const APP_ELEMENTS_SCHEMA_VERSION = 1;
 const RSC_PAYLOAD_SCHEMA_VERSION = 1;
-const ARTIFACT_COMPATIBILITY_PROOF_FIELDS = [
-	"schemaVersion",
-	"graphVersion",
-	"deploymentVersion",
-	"appElementsSchemaVersion",
-	"rscPayloadSchemaVersion",
-	"rootBoundaryId",
-	"renderEpoch"
-];
 function createArtifactCompatibilityEnvelope(input = {}) {
 	return {
 		schemaVersion: 1,
@@ -88,4 +79,4 @@ function evaluateArtifactCompatibility(current, candidate, options = {}) {
 	return { kind: "compatible" };
 }
 //#endregion
-export { APP_ELEMENTS_SCHEMA_VERSION, ARTIFACT_COMPATIBILITY_PROOF_FIELDS, ARTIFACT_COMPATIBILITY_SCHEMA_VERSION, RSC_PAYLOAD_SCHEMA_VERSION, createArtifactCompatibilityEnvelope, createArtifactCompatibilityGraphVersion, evaluateArtifactCompatibility, parseArtifactCompatibilityEnvelope };
+export { APP_ELEMENTS_SCHEMA_VERSION, ARTIFACT_COMPATIBILITY_SCHEMA_VERSION, RSC_PAYLOAD_SCHEMA_VERSION, createArtifactCompatibilityEnvelope, createArtifactCompatibilityGraphVersion, evaluateArtifactCompatibility, parseArtifactCompatibilityEnvelope };

package/dist/server/bfcache-identity.d.ts

@@ -41,4 +41,5 @@ export type BfcacheSegmentDescriptor = {
   sourceBoundSegmentKey: string;
 };
 export declare function deriveBfcacheSegmentIdentity(descriptor: BfcacheSegmentDescriptor): string;
-//#endregion
+//#endregion
+export {};

package/dist/server/cache-headers.d.ts

@@ -2,4 +2,5 @@
 type VinextCacheState = "HIT" | "MISS" | "STALE" | "STATIC";
 export declare function setCacheStateHeaders(headers: Headers, cacheState: VinextCacheState): void;
 export declare function buildCacheStateHeaders(cacheState: VinextCacheState): Record<string, string>;
-//#endregion
+//#endregion
+export {};