vinext 1.0.0-beta.9 → 1.0.0

package/dist/server/request-tracing.js

@@ -0,0 +1,180 @@
+import { getOrCreateAls } from "../shims/internal/als-registry.js";
+import { isFullyBufferedBody, markFullyBufferedBody, preserveFullyBufferedBodyMetadata } from "./fully-buffered-response.js";
+import { VINEXT_TRACE_BUFFERED_BODY_HEADER, VINEXT_TRACE_ERROR_HEADER, VINEXT_TRACE_ROUTE_HEADER } from "./headers.js";
+import { frameworkTracer } from "./tracer.js";
+import { deferUntilStreamConsumed } from "./defer-until-stream-consumed.js";
+import { getResponseStartCompletion } from "./response-start-tracing.js";
+//#region src/server/request-tracing.ts
+const activeRequestTrace = getOrCreateAls("vinext.requestTracing.als");
+function setFrameworkRequestRoute(route, isRsc) {
+	activeRequestTrace.getStore()?.setRoute(route, isRsc);
+}
+function updateResponseHeader(response, name, value) {
+	try {
+		if (value === void 0) response.headers.delete(name);
+		else response.headers.set(name, value);
+		return response;
+	} catch {}
+	const rebuilt = preserveFullyBufferedBodyMetadata(response, new Response(response.body, response));
+	if (value === void 0) rebuilt.headers.delete(name);
+	else rebuilt.headers.set(name, value);
+	return rebuilt;
+}
+async function captureFrameworkRequestRoute(callback, onRoute) {
+	let route;
+	return {
+		result: await activeRequestTrace.run({
+			recordError() {},
+			setRoute(nextRoute) {
+				if (route === void 0 && nextRoute !== void 0) {
+					route = nextRoute;
+					onRoute?.(nextRoute);
+				}
+			}
+		}, callback),
+		route
+	};
+}
+function attachFrameworkRequestRoute(response, route) {
+	return updateResponseHeader(updateResponseHeader(response, VINEXT_TRACE_BUFFERED_BODY_HEADER, isFullyBufferedBody(response) ? "1" : void 0), VINEXT_TRACE_ROUTE_HEADER, route ? encodeURIComponent(route) : void 0);
+}
+function clearFrameworkRequestError(response) {
+	return updateResponseHeader(response, VINEXT_TRACE_ERROR_HEADER, void 0);
+}
+function attachFrameworkRequestError(response, error) {
+	const descriptor = error instanceof Error ? {
+		message: error.message.slice(0, 2048),
+		name: error.name.slice(0, 128)
+	} : {
+		message: String(error).slice(0, 2048),
+		name: typeof error
+	};
+	return updateResponseHeader(response, VINEXT_TRACE_ERROR_HEADER, encodeURIComponent(JSON.stringify(descriptor)));
+}
+function consumeFrameworkRequestRoute(response) {
+	const fullyBuffered = response.headers.get(VINEXT_TRACE_BUFFERED_BODY_HEADER) === "1";
+	const encodedRoute = response.headers.get(VINEXT_TRACE_ROUTE_HEADER);
+	if (encodedRoute !== null) try {
+		const route = decodeURIComponent(encodedRoute);
+		if (route.startsWith("/")) setFrameworkRequestRoute(route);
+	} catch {}
+	const encodedError = response.headers.get(VINEXT_TRACE_ERROR_HEADER);
+	if (encodedError !== null) try {
+		const descriptor = JSON.parse(decodeURIComponent(encodedError));
+		if (typeof descriptor.message === "string" && typeof descriptor.name === "string") {
+			const error = new Error(descriptor.message);
+			error.name = descriptor.name;
+			activeRequestTrace.getStore()?.recordError(error);
+		}
+	} catch {}
+	const cleaned = updateResponseHeader(updateResponseHeader(updateResponseHeader(response, VINEXT_TRACE_BUFFERED_BODY_HEADER, void 0), VINEXT_TRACE_ROUTE_HEADER, void 0), VINEXT_TRACE_ERROR_HEADER, void 0);
+	return fullyBuffered ? markFullyBufferedBody(cleaned) : cleaned;
+}
+function traceFrameworkRequest(input) {
+	if (activeRequestTrace.getStore() && !input.detached) return input.callback();
+	const method = input.method.toUpperCase();
+	const trace = () => frameworkTracer.withPropagatedContext(input.headers, () => {
+		const parentSpan = frameworkTracer.getActiveScopeSpan();
+		let resolveResult;
+		let rejectResult;
+		const resultPromise = new Promise((resolve, reject) => {
+			resolveResult = resolve;
+			rejectResult = reject;
+		});
+		frameworkTracer.trace({
+			attributes: {
+				"http.method": method,
+				"http.target": input.target
+			},
+			kind: "server",
+			name: method,
+			type: "BaseServer.handleRequest"
+		}, async (span) => {
+			let carriedError;
+			let route;
+			let isRsc = input.isRsc ?? false;
+			let result;
+			let spanFinalized = false;
+			const finalizeSpan = () => {
+				if (spanFinalized) return;
+				spanFinalized = true;
+				finalizeFrameworkRequestSpan({
+					carriedError,
+					input,
+					isRsc,
+					method,
+					parentSpan,
+					result,
+					route,
+					span
+				});
+			};
+			try {
+				result = await activeRequestTrace.run({
+					recordError(error) {
+						carriedError = error;
+					},
+					setRoute(nextRoute, nextIsRsc) {
+						if (route === void 0 && nextRoute !== void 0) route = nextRoute;
+						if (nextIsRsc !== void 0) isRsc = nextIsRsc;
+					}
+				}, input.callback);
+				finalizeSpan();
+				if (result instanceof Response && result.body && !result.body.locked && !isFullyBufferedBody(result)) {
+					let finishBody;
+					let failBody;
+					const bodyCompletion = new Promise((resolve, reject) => {
+						finishBody = resolve;
+						failBody = reject;
+					});
+					result = wrapResponseBody(result, finishBody, failBody);
+					resolveResult(result);
+					await bodyCompletion;
+					return result;
+				}
+				resolveResult(result);
+				if (result instanceof Response) await getResponseStartCompletion(result);
+				return result;
+			} catch (error) {
+				finalizeSpan();
+				rejectResult(error);
+				throw error;
+			}
+		}).catch(() => {});
+		return resultPromise;
+	});
+	return input.detached ? frameworkTracer.runWithDetachedContext(trace) : trace();
+}
+function finalizeFrameworkRequestSpan(options) {
+	const { carriedError, input, isRsc, method, parentSpan, result, route, span } = options;
+	const status = input.getStatus(result);
+	span.setAttributes({
+		"http.status_code": status,
+		"next.rsc": isRsc
+	});
+	if (status !== void 0 && status >= 500) {
+		span.setErrorStatus();
+		span.setAttribute("error.type", String(status));
+	}
+	if (carriedError) {
+		span.recordException(carriedError);
+		if (status === void 0 || status < 500) {
+			span.setAttribute("error.type", carriedError.name);
+			span.setErrorStatus(carriedError.message);
+		}
+	}
+	const name = route ? `${isRsc ? "RSC " : ""}${method} ${route}` : `${isRsc ? "RSC " : ""}${method}`;
+	if (route) {
+		span.setAttributes({
+			"http.route": route,
+			"next.route": route
+		});
+		parentSpan?.setAttribute("http.route", route);
+	}
+	span.updateName(name);
+}
+function wrapResponseBody(response, onConsumed, onError) {
+	return new Response(deferUntilStreamConsumed(response.body, onConsumed, onError), response);
+}
+//#endregion
+export { attachFrameworkRequestError, attachFrameworkRequestRoute, captureFrameworkRequestRoute, clearFrameworkRequestError, consumeFrameworkRequestRoute, setFrameworkRequestRoute, traceFrameworkRequest };

package/dist/server/response-stage-cacheability.d.ts

@@ -0,0 +1,37 @@
+import { CacheabilityRepresentation } from "./cacheability-manifest.js";
+import { VinextResponseStageDispatchOptions } from "./multi-stage.js";
+import { ExecutionContextLike } from "../shims/request-context.js";
+import { WorkerCacheabilityProbeMode } from "./cacheability-request.js";
+//#region src/server/response-stage-cacheability.d.ts
+export type ResponseStageCacheabilityOptions = {
+  buildId: string | null | undefined;
+  cache: VinextResponseStageDispatchOptions["cache"];
+  context: ExecutionContextLike;
+  forceDynamic?: boolean;
+  probeMode?: WorkerCacheabilityProbeMode | null;
+  policyHeaders?: ReadonlyArray<readonly [string, string]> | null;
+  /** The renderer receives policy before user Pages code and applies it itself. */
+  policyHeadersAppliedBeforeRender?: boolean;
+  rawManifest: string | null | undefined;
+  /** The trusted route target after request-stage rewrites. */
+  resolvedRoutePathname?: string;
+  /** Trusted representation retained when request-stage normalization changes the URL shape. */
+  representation?: CacheabilityRepresentation;
+  /**
+   * The request stage recomposes `X-Vinext-Params` and
+   * `X-Vinext-Rendered-Path-And-Search` per request (App page RSC), so a
+   * shared response drops them before admission and storage.
+   */
+  recomposesRequestScopedHeaders?: boolean;
+  /** Generated adapter registration, deferred until the response stage executes. */
+  registerCacheAdapters(): void;
+  request: Request;
+};
+/**
+ * Run a response-stage render behind completed-response cache admission.
+ *
+ * Adapter registration and cacheability state live here so a shared transport
+ * hit can avoid loading the response stage and its application graph entirely.
+ */
+export declare function withResponseStageCacheability(options: ResponseStageCacheabilityOptions, render: (context: ExecutionContextLike) => Promise<Response>): Promise<Response>;
+//#endregion

package/dist/server/response-stage-cacheability.js

@@ -0,0 +1,55 @@
+import { preserveFullyBufferedBodyMetadata } from "./fully-buffered-response.js";
+import { VINEXT_PARAMS_HEADER, VINEXT_RENDERED_PATH_AND_SEARCH_HEADER } from "./headers.js";
+import { getCdnCacheAdapter } from "../shims/cdn-cache.js";
+import { CACHEABILITY_REQUEST_STATE } from "../shims/cacheability-classification.js";
+//#region src/server/response-stage-cacheability.ts
+/**
+* Run a response-stage render behind completed-response cache admission.
+*
+* Adapter registration and cacheability state live here so a shared transport
+* hit can avoid loading the response stage and its application graph entirely.
+*/
+async function withResponseStageCacheability(options, render) {
+	options.registerCacheAdapters();
+	const adapter = getCdnCacheAdapter();
+	let context = options.context;
+	let cacheability;
+	if (options.probeMode) {
+		cacheability = await import("./cacheability-request.js");
+		context = cacheability.createWorkerCacheabilityProbeContext(context, options.probeMode, adapter.responseVary, options.resolvedRoutePathname);
+	} else if (options.cache === "shared" && (options.rawManifest != null || adapter.requiresCompletedResponseAdmission === true)) {
+		cacheability = await import("./cacheability-request.js");
+		context = cacheability.createWorkerCacheabilityAdmissionContext(context, options.request, options.rawManifest, options.buildId, adapter.requiresCompletedResponseAdmission === true, adapter.responseVary, options.resolvedRoutePathname, options.representation, { applyCompletedResponsePolicy: true });
+	}
+	const stripsRequestScopedHeaders = options.recomposesRequestScopedHeaders === true && options.cache === "shared" && !options.probeMode;
+	if (!cacheability) {
+		const rendered = await render(context);
+		return stripsRequestScopedHeaders ? withoutRequestScopedHeaders(rendered) : rendered;
+	}
+	if (options.policyHeadersAppliedBeforeRender) cacheability.recordResponseStageCachePolicy(context, options.policyHeaders);
+	const state = Reflect.get(context, CACHEABILITY_REQUEST_STATE);
+	if (options.probeMode && options.forceDynamic && !options.policyHeaders?.length && state) state.patternDynamicReason = "dynamic = \"force-dynamic\"";
+	const renderedResponse = await render(context);
+	const rendered = stripsRequestScopedHeaders ? withoutRequestScopedHeaders(renderedResponse) : renderedResponse;
+	const response = options.policyHeadersAppliedBeforeRender ? rendered : cacheability.applyResponseStageCachePolicy(rendered, context, options.policyHeaders);
+	const complete = (candidate) => cacheability.finalizeWorkerCacheabilityResponse(candidate, context);
+	const route = state?.route;
+	if (!options.probeMode && state?.admission?.policy !== "manifest" && (route?.kind === "app-page" || route?.kind === "pages-page")) {
+		const deferred = adapter.deferCompletedPageResponseAdmission?.(response, complete);
+		if (deferred) return deferred;
+	}
+	return complete(response);
+}
+function withoutRequestScopedHeaders(response) {
+	if (!response.headers.has("X-Vinext-Params") && !response.headers.has("X-Vinext-Rendered-Path-And-Search")) return response;
+	const headers = new Headers(response.headers);
+	headers.delete(VINEXT_PARAMS_HEADER);
+	headers.delete(VINEXT_RENDERED_PATH_AND_SEARCH_HEADER);
+	return preserveFullyBufferedBodyMetadata(response, new Response(response.body, {
+		headers,
+		status: response.status,
+		statusText: response.statusText
+	}));
+}
+//#endregion
+export { withResponseStageCacheability };

package/dist/server/response-stage-policy.d.ts

@@ -0,0 +1,23 @@
+import { PagesResponseStagePolicyOwner } from "./worker-stages.js";
+//#region src/server/response-stage-policy.d.ts
+/** Apply request-stage cache policy before response-stage admission. */
+export declare function applyResponseStagePolicyHeaders(headers: Headers, policyHeaders: ReadonlyArray<readonly [string, string]> | null | undefined): void;
+/**
+ * Remove the copy of staged cookies that a response handler inherited before
+ * it ran. The request stage composes those cookies again after transport, so
+ * retaining the inherited copies would emit them twice. Multiset subtraction
+ * preserves additional identical cookies deliberately appended by user code.
+ */
+export declare function stripInheritedResponseStageCookies(response: Response, stagedHeaders: Headers): Response;
+/** Replace transported Vary fields with the effective request-stage value. */
+export declare function withResponseStageVary(policyHeaders: ReadonlyArray<readonly [string, string]> | null | undefined, vary: string | null | undefined): Array<[string, string]> | null;
+/** Keep request-stage-only variance outside a reusable response artifact. */
+export declare function withoutResponseStageVary(policyHeaders: ReadonlyArray<readonly [string, string]> | null | undefined): Array<[string, string]> | null;
+/** Recompose additive request-stage headers before the rendered response values. */
+export declare function prependResponseStageAdditiveHeaders(responseHeaders: Headers, outerHeaders: Headers): void;
+/** Consume trusted Pages response-stage policy ownership before public egress. */
+export declare function consumePagesResponseStagePolicyOwner(response: Response): {
+  owner: PagesResponseStagePolicyOwner | null;
+  response: Response;
+};
+//#endregion

package/dist/server/response-stage-policy.js

@@ -0,0 +1,89 @@
+import { preserveFullyBufferedBodyMetadata } from "./fully-buffered-response.js";
+import "../shims/unified-request-context.js";
+import { mergeVaryHeader } from "./middleware-response-headers.js";
+import { PAGES_RESPONSE_STAGE_POLICY_OWNER_HEADER } from "./worker-stages.js";
+//#region src/server/response-stage-policy.ts
+/** Apply request-stage cache policy before response-stage admission. */
+function applyResponseStagePolicyHeaders(headers, policyHeaders) {
+	for (const [name, value] of policyHeaders ?? []) if (name.toLowerCase() === "vary") mergeVaryHeader(headers, value);
+	else headers.set(name, value);
+}
+/**
+* Remove the copy of staged cookies that a response handler inherited before
+* it ran. The request stage composes those cookies again after transport, so
+* retaining the inherited copies would emit them twice. Multiset subtraction
+* preserves additional identical cookies deliberately appended by user code.
+*/
+function stripInheritedResponseStageCookies(response, stagedHeaders) {
+	const stagedCookies = stagedHeaders.getSetCookie();
+	if (stagedCookies.length === 0) return response;
+	const responseCookies = response.headers.getSetCookie();
+	let removed = false;
+	for (const stagedCookie of stagedCookies) {
+		const index = responseCookies.indexOf(stagedCookie);
+		if (index === -1) continue;
+		responseCookies.splice(index, 1);
+		removed = true;
+	}
+	if (!removed) return response;
+	const headers = new Headers(response.headers);
+	headers.delete("Set-Cookie");
+	for (const cookie of responseCookies) headers.append("Set-Cookie", cookie);
+	return preserveFullyBufferedBodyMetadata(response, new Response(response.body, {
+		headers,
+		status: response.status,
+		statusText: response.statusText
+	}));
+}
+/** Replace transported Vary fields with the effective request-stage value. */
+function withResponseStageVary(policyHeaders, vary) {
+	const result = [];
+	const varyHeaders = new Headers();
+	for (const [name, value] of policyHeaders ?? []) if (name.toLowerCase() === "vary") mergeVaryHeader(varyHeaders, value);
+	else result.push([name, value]);
+	if (vary) mergeVaryHeader(varyHeaders, vary);
+	const effectiveVary = varyHeaders.get("Vary");
+	if (effectiveVary) result.push(["Vary", effectiveVary]);
+	return result.length > 0 ? result : null;
+}
+/** Keep request-stage-only variance outside a reusable response artifact. */
+function withoutResponseStageVary(policyHeaders) {
+	const result = (policyHeaders ?? []).filter(([name]) => name.toLowerCase() !== "vary");
+	return result.length > 0 ? result.map(([name, value]) => [name, value]) : null;
+}
+/** Recompose additive request-stage headers before the rendered response values. */
+function prependResponseStageAdditiveHeaders(responseHeaders, outerHeaders) {
+	const outerLink = outerHeaders.get("link");
+	if (outerLink) {
+		const responseLink = responseHeaders.get("link");
+		responseHeaders.set("link", responseLink ? `${outerLink}, ${responseLink}` : outerLink);
+	}
+	const outerVary = outerHeaders.get("vary");
+	if (outerVary) {
+		const responseVary = responseHeaders.get("vary");
+		responseHeaders.delete("vary");
+		mergeVaryHeader(responseHeaders, outerVary);
+		if (responseVary) mergeVaryHeader(responseHeaders, responseVary);
+	}
+}
+/** Consume trusted Pages response-stage policy ownership before public egress. */
+function consumePagesResponseStagePolicyOwner(response) {
+	const value = response.headers.get(PAGES_RESPONSE_STAGE_POLICY_OWNER_HEADER);
+	const owner = value === "request-time" || value === "static" ? value : null;
+	if (value === null) return {
+		owner,
+		response
+	};
+	const headers = new Headers(response.headers);
+	headers.delete(PAGES_RESPONSE_STAGE_POLICY_OWNER_HEADER);
+	return {
+		owner,
+		response: preserveFullyBufferedBodyMetadata(response, new Response(response.body, {
+			headers,
+			status: response.status,
+			statusText: response.statusText
+		}))
+	};
+}
+//#endregion
+export { applyResponseStagePolicyHeaders, consumePagesResponseStagePolicyOwner, prependResponseStageAdditiveHeaders, stripInheritedResponseStageCookies, withResponseStageVary, withoutResponseStageVary };

package/dist/server/response-stage.d.ts

@@ -0,0 +1,5 @@
+import { VinextResponseStageModule } from "./multi-stage.js";
+//#region src/server/response-stage.d.ts
+/** Lazily load the router-specific response stage selected by vinext. */
+export declare function loadVinextResponseStage<Env = unknown, Context = unknown>(): Promise<VinextResponseStageModule<Env, Context>>;
+//#endregion

package/dist/server/response-stage.js

@@ -0,0 +1,7 @@
+//#region src/server/response-stage.ts
+/** Lazily load the router-specific response stage selected by vinext. */
+function loadVinextResponseStage() {
+	return import("virtual:vinext-response-stage");
+}
+//#endregion
+export { loadVinextResponseStage };

package/dist/server/response-start-tracing.d.ts

@@ -0,0 +1,14 @@
+//#region src/server/response-start-tracing.d.ts
+export declare function getResponseStartCompletion(response: Response): Promise<void> | undefined;
+export declare function createResponseStartSpanDescriptor(): {
+  readonly name: "start response";
+  readonly type: "NextNodeServer.startResponse";
+};
+export declare function traceResponseStartWithCompletion(response: Response): {
+  response: Response;
+  started: Promise<void>;
+};
+export declare function traceResponseStart(response: Response): Response;
+/** Trace a response replayed by a cache above the framework renderer. */
+export declare function traceCachedResponseStart(response: Response, cacheStatus: string | null, responseStageProps: unknown): Response;
+//#endregion

package/dist/server/response-start-tracing.js

@@ -0,0 +1,80 @@
+import { preserveFullyBufferedBodyMetadata } from "./fully-buffered-response.js";
+import { frameworkTracer } from "./tracer.js";
+import { copyLinkHeaderProvenance } from "./app-response-header-provenance.js";
+//#region src/server/response-start-tracing.ts
+const tracedResponses = /* @__PURE__ */ new WeakMap();
+function getResponseStartCompletion(response) {
+	return tracedResponses.get(response);
+}
+function createResponseStartSpanDescriptor() {
+	return {
+		name: "start response",
+		type: "NextNodeServer.startResponse"
+	};
+}
+function traceResponseStartStream(stream, onSettled) {
+	const reader = stream.getReader();
+	const runInTraceContext = frameworkTracer.captureActiveContext();
+	let started = false;
+	return new ReadableStream({
+		async pull(controller) {
+			try {
+				const result = await reader.read();
+				if (result.done) {
+					onSettled();
+					controller.close();
+					return;
+				}
+				if (!started) {
+					started = true;
+					runInTraceContext(() => frameworkTracer.trace(createResponseStartSpanDescriptor(), () => void 0));
+					onSettled();
+				}
+				controller.enqueue(result.value);
+			} catch (error) {
+				onSettled();
+				controller.error(error);
+			}
+		},
+		async cancel(reason) {
+			try {
+				await reader.cancel(reason);
+			} finally {
+				onSettled();
+			}
+		}
+	}, { highWaterMark: 0 });
+}
+function traceResponseStartWithCompletion(response) {
+	const existing = tracedResponses.get(response);
+	if (existing) return {
+		response,
+		started: existing
+	};
+	if (!response.body) return {
+		response,
+		started: Promise.resolve()
+	};
+	let onSettled;
+	const started = new Promise((resolve) => {
+		onSettled = resolve;
+	});
+	const traced = preserveFullyBufferedBodyMetadata(response, new Response(traceResponseStartStream(response.body, onSettled), response));
+	copyLinkHeaderProvenance(response.headers, traced.headers);
+	tracedResponses.set(traced, started);
+	return {
+		response: traced,
+		started
+	};
+}
+function traceResponseStart(response) {
+	return traceResponseStartWithCompletion(response).response;
+}
+/** Trace a response replayed by a cache above the framework renderer. */
+function traceCachedResponseStart(response, cacheStatus, responseStageProps) {
+	const props = responseStageProps && typeof responseStageProps === "object" ? responseStageProps : null;
+	const kind = props ? Reflect.get(props, "kind") : void 0;
+	return (kind === "app-route-handler" || kind === "app-page" && props !== null && Reflect.get(props, "isRscRequest") === false) && (cacheStatus === "HIT" || cacheStatus === "STALE" || cacheStatus === "REVALIDATED" || cacheStatus === "UPDATING") ? traceResponseStart(response) : response;
+}
+//#endregion
+export { createResponseStartSpanDescriptor, getResponseStartCompletion, traceCachedResponseStart, traceResponseStart, traceResponseStartWithCompletion };

package/dist/server/revalidation-host.d.ts

@@ -5,6 +5,5 @@ import { NextI18nConfig } from "../config/next-config.js";
  * loopback. The side channel is accepted only as part of the authenticated
  * revalidation protocol and only for an exact configured i18n domain.
  */
-declare function readTrustedRevalidationHostname(headers: Headers, i18nConfig: NextI18nConfig | null | undefined, authorizeRevalidation?: (headerValue: string | null) => boolean): string | null;
-//#endregion
-export { readTrustedRevalidationHostname };
+export declare function readTrustedRevalidationHostname(headers: Headers, i18nConfig: NextI18nConfig | null | undefined, authorizeRevalidation?: (headerValue: string | null) => boolean): string | null;
+//#endregion

package/dist/server/revalidation-host.js

@@ -1,7 +1,7 @@
 import { VINEXT_REVALIDATE_HOST_HEADER } from "../utils/protocol-headers.js";
 import "./headers.js";
 import { normalizeDomainHostname } from "../utils/domain-locale.js";
-import { isOnDemandRevalidateRequest } from "./isr-cache.js";
+import { isOnDemandRevalidateRequest } from "./revalidation-request.js";
 //#region src/server/revalidation-host.ts
 /**
 * Read the logical request hostname carried by a server-pinned revalidation

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

@@ -0,0 +1,8 @@
+import { PRERENDER_REVALIDATE_HEADER } from "../utils/protocol-headers.js";
+//#region src/server/revalidation-request.d.ts
+export declare function getRevalidateSecret(): string;
+export declare function isRevalidateSecret(value: string | null | undefined): boolean;
+/** Match Next.js: the header value must equal the preview/revalidation secret. */
+export declare function isOnDemandRevalidateRequest(headerValue: string | string[] | null | undefined): boolean;
+//#endregion
+export { PRERENDER_REVALIDATE_HEADER };

package/dist/server/revalidation-request.js

@@ -0,0 +1,37 @@
+import { PRERENDER_REVALIDATE_HEADER } from "../utils/protocol-headers.js";
+//#region src/server/revalidation-request.ts
+/**
+* Request-only on-demand revalidation authentication.
+*
+* Keep this module independent from ISR storage and renderer code so a routing
+* stage can authorize a reverse revalidation call without evaluating React.
+*/
+const DEV_REVALIDATE_SECRET_KEY = Symbol.for("vinext.isrCache.devRevalidateSecret");
+function getRevalidateSecret() {
+	const baked = process.env.__VINEXT_REVALIDATE_SECRET;
+	if (baked) return baked;
+	const globals = globalThis;
+	const existing = globals[DEV_REVALIDATE_SECRET_KEY];
+	if (typeof existing === "string") return existing;
+	const bytes = /* @__PURE__ */ new Uint8Array(32);
+	crypto.getRandomValues(bytes);
+	const secret = Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+	globals[DEV_REVALIDATE_SECRET_KEY] = secret;
+	return secret;
+}
+function safeEqual(first, second) {
+	if (first.length !== second.length) return false;
+	let mismatch = 0;
+	for (let index = 0; index < first.length; index++) mismatch |= first.charCodeAt(index) ^ second.charCodeAt(index);
+	return mismatch === 0;
+}
+function isRevalidateSecret(value) {
+	if (typeof value !== "string" || value.length === 0) return false;
+	return safeEqual(value, getRevalidateSecret());
+}
+/** Match Next.js: the header value must equal the preview/revalidation secret. */
+function isOnDemandRevalidateRequest(headerValue) {
+	return typeof headerValue === "string" && isRevalidateSecret(headerValue);
+}
+//#endregion
+export { PRERENDER_REVALIDATE_HEADER, getRevalidateSecret, isOnDemandRevalidateRequest, isRevalidateSecret };

package/dist/server/rsc-completion-metadata.d.ts

@@ -1,15 +1,14 @@
 //#region src/server/rsc-completion-metadata.d.ts
-type RscCompletionMetadata = Readonly<{
+export type RscCompletionMetadata = Readonly<{
   dynamicStaleTimeSeconds: number;
   serverStaleTimeSeconds?: number | null;
 }>;
-declare function extractRscCompletionMetadata(buffer: ArrayBuffer): {
+export declare function extractRscCompletionMetadata(buffer: ArrayBuffer): {
   buffer: ArrayBuffer;
   metadata?: RscCompletionMetadata;
 };
-declare function appendRscCompletionMetadata(source: ReadableStream<Uint8Array>, getMetadata: () => RscCompletionMetadata | undefined): ReadableStream<Uint8Array>;
-declare function stripRscCompletionMetadata(source: ReadableStream<Uint8Array>): ReadableStream<Uint8Array>;
+export declare function appendRscCompletionMetadata(source: ReadableStream<Uint8Array>, getMetadata: () => RscCompletionMetadata | undefined): ReadableStream<Uint8Array>;
+export declare function stripRscCompletionMetadata(source: ReadableStream<Uint8Array>): ReadableStream<Uint8Array>;
 /** Remove vinext's internal completion footer before React reads a Flight response. */
-declare function stripRscCompletionMetadataResponse(response: Response): Response;
-//#endregion
-export { RscCompletionMetadata, appendRscCompletionMetadata, extractRscCompletionMetadata, stripRscCompletionMetadata, stripRscCompletionMetadataResponse };
+export declare function stripRscCompletionMetadataResponse(response: Response): Response;
+//#endregion

package/dist/server/rsc-stream-hints.d.ts

@@ -1,10 +1,21 @@
 //#region src/server/rsc-stream-hints.d.ts
-declare function normalizeReactFlightPreloadHints(stream: ReadableStream<Uint8Array>): ReadableStream<Uint8Array>;
-type RscRawRenderer = (model: unknown, options?: unknown) => ReadableStream<Uint8Array>;
-type RscRawPrerenderer = (model: unknown, options?: unknown) => Promise<{
+/**
+ * Rewrite stylesheet preload hints in a React Flight stream.
+ *
+ * The rewrite is byte-length preserving, so this transform keeps React's
+ * text chunk boundaries instead of re-emitting one chunk per Flight row. Every
+ * downstream consumer (the tee, the SSR Flight client, the inline RSC embed,
+ * RSC response wrappers) pays a per-chunk cost, and splitting per row
+ * multiplied the chunk count roughly 8x on content-heavy pages. Chunks with
+ * no stylesheet hint are forwarded as-is without copying; only rows whose
+ * tag is `HL` are decoded and inspected. Length-prefixed bodies remain separate
+ * so binary bytes do not force adjacent text through the embed's base64 path.
+ */
+export declare function normalizeReactFlightPreloadHints(stream: ReadableStream<Uint8Array>): ReadableStream<Uint8Array>;
+export type RscRawRenderer = (model: unknown, options?: unknown) => ReadableStream<Uint8Array>;
+export type RscRawPrerenderer = (model: unknown, options?: unknown) => Promise<{
   prelude: ReadableStream<Uint8Array>;
 }>;
-declare function createRscRenderer(render: RscRawRenderer): RscRawRenderer;
-declare function createRscPrerenderer(prerender: RscRawPrerenderer): RscRawPrerenderer;
-//#endregion
-export { RscRawPrerenderer, RscRawRenderer, createRscPrerenderer, createRscRenderer, normalizeReactFlightPreloadHints };
+export declare function createRscRenderer(render: RscRawRenderer): RscRawRenderer;
+export declare function createRscPrerenderer(prerender: RscRawPrerenderer): RscRawPrerenderer;
+//#endregion