vinext 1.3.0 → 1.4.0

package/dist/server/html.js

@@ -37,6 +37,24 @@ function safeJsonStringify(data) {
 	if (!HTML_UNSAFE_JSON_CHAR_RE.test(json)) return json;
 	return json.replace(HTML_UNSAFE_JSON_CHARS_RE, escapeHtmlUnsafeJsonChar);
 }
+/**
+* Minimal escaping for JSON that is only ever embedded as the content of a
+* classic inline <script> element. The HTML spec only forbids "<!--",
+* "<script" and "<\/script" (ASCII case-insensitive) in script content, so
+* only a '<' that begins one of those is escaped; '>' and '&' have no
+* meaning there.
+* https://html.spec.whatwg.org/multipage/scripting.html#restrictions-for-contents-of-script-elements
+*
+* Used for the large RSC payload chunks: leaving markup such as "<p>" intact
+* lets compression match it against the identical SSR markup. Do not use
+* this for values that can land outside a script element.
+*/
+const SCRIPT_UNSAFE_JSON_CHARS_RE = /<(?=!--|\/?script)|[\u2028\u2029]/gi;
+function scriptSafeJsonStringify(data) {
+	const json = JSON.stringify(data);
+	if (json === void 0) throw new TypeError("Cannot serialize value as JSON");
+	return json.replace(SCRIPT_UNSAFE_JSON_CHARS_RE, escapeHtmlUnsafeJsonChar);
+}
 function escapeHtmlAttr(value) {
 	return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 }
@@ -53,4 +71,4 @@ function createInlineScriptTag(content, nonce) {
 	return `<script${createNonceAttribute(nonce)}>${content}<\/script>`;
 }
 //#endregion
-export { createInlineScriptTag, createNonceAttribute, escapeHtmlAttr, htmlTokenListContains, safeJsonStringify };
+export { createInlineScriptTag, createNonceAttribute, escapeHtmlAttr, htmlTokenListContains, safeJsonStringify, scriptSafeJsonStringify };

package/dist/server/http-conditional.d.ts

@@ -29,4 +29,5 @@ type StaticConditionalHeaders = {
 export type StaticPreconditionResult = "proceed" | "not-modified" | "precondition-failed";
 /** Evaluate static representation preconditions in RFC 9110 section 13.2.2 order. */
 export declare function evaluateStaticPreconditions(headers: StaticConditionalHeaders, method: string | undefined, etag: string | undefined, mtimeMs: number): StaticPreconditionResult;
-//#endregion
+//#endregion
+export {};

package/dist/server/http-error-responses.d.ts

@@ -88,4 +88,5 @@ export declare function payloadTooLargeResponse(): Response;
  * to use the canonical "Internal Server Error" body.
  */
 export declare function internalServerErrorResponse(message?: string, init?: ErrorResponseInit): Response;
-//#endregion
+//#endregion
+export {};

package/dist/server/implicit-tags.d.ts

@@ -2,4 +2,5 @@
 type AppCacheLeafKind = "page" | "route";
 export declare function buildAppPageTags(cleanPathname: string, extraTags: string[], routeSegments: readonly string[]): string[];
 export declare function buildPageCacheTags(pathname: string, extraTags: string[], routeSegments: string[], leafKind: AppCacheLeafKind): string[];
-//#endregion
+//#endregion
+export {};

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

@@ -1,7 +1,7 @@
-import { OnRequestErrorContext } from "./instrumentation.js";
-import { PRERENDER_REVALIDATE_HEADER, PRERENDER_REVALIDATE_ONLY_GENERATED_HEADER } from "../utils/protocol-headers.js";
 import { RenderObservation } from "./cache-proof.js";
 import { AppRscRenderMode } from "./app-rsc-render-mode.js";
+import { OnRequestErrorContext } from "./instrumentation.js";
+import { PRERENDER_REVALIDATE_HEADER, PRERENDER_REVALIDATE_ONLY_GENERATED_HEADER } from "../utils/protocol-headers.js";
 import { normalizeMountedSlotsHeader } from "./app-mounted-slots-header.js";
 import { CacheControlMetadata, CacheHandlerValue, CachedAppPageValue, CachedPagesValue, IncrementalCacheValue } from "../shims/cache-handler.js";
 import { getRevalidateSecret, isOnDemandRevalidateRequest, isRevalidateSecret } from "./revalidation-request.js";
@@ -68,6 +68,12 @@ export declare function isrSetPrerenderedAppPage(key: string, data: CachedAppPag
 }): Promise<void>;
 /** Coalesce same-key synchronous on-demand revalidations. */
 export declare function coalesceOnDemandRevalidation<T>(key: string, renderFn: () => Promise<T>): Promise<T>;
+/**
+ * Coalesce same-key on-demand revalidations whose render answers with a
+ * Response, or null for no match. Every caller gets its own copy of the one
+ * render's response. `method` is the request method the response answers.
+ */
+export declare function coalesceOnDemandResponse<R extends Response | null>(key: string, method: string, renderFn: () => Promise<R>): Promise<R>;
 /**
  * Trigger a background regeneration for a cache key.
  *

package/dist/server/isr-cache.js

@@ -101,6 +101,31 @@ function coalesceOnDemandRevalidation(key, renderFn) {
 	return promise;
 }
 /**
+* Coalesce same-key on-demand revalidations whose render answers with a
+* Response, or null for no match. Every caller gets its own copy of the one
+* render's response. `method` is the request method the response answers.
+*/
+async function coalesceOnDemandResponse(key, method, renderFn) {
+	const snapshot = await coalesceOnDemandRevalidation(key, async () => {
+		const response = await renderFn();
+		if (!response) return null;
+		const hasBody = method !== "HEAD" && response.status !== 204 && response.status !== 205 && response.status !== 304;
+		if (!hasBody) await response.body?.cancel();
+		return {
+			body: hasBody ? new Uint8Array(await response.arrayBuffer()) : null,
+			headers: [...response.headers.entries()],
+			status: response.status,
+			statusText: response.statusText
+		};
+	});
+	if (!snapshot) return null;
+	return new Response(snapshot.body?.slice() ?? null, {
+		headers: snapshot.headers,
+		status: snapshot.status,
+		statusText: snapshot.statusText
+	});
+}
+/**
 * Trigger a background regeneration for a cache key.
 *
 * If a regeneration for this key is already in progress, this is a no-op.
@@ -247,4 +272,4 @@ function appIsrRouteKey(pathname) {
 	return appIsrCacheKey(pathname, pathname !== "/" && pathname.endsWith("/") ? "route:trailing-slash" : "route");
 }
 //#endregion
-export { PRERENDER_REVALIDATE_HEADER, PRERENDER_REVALIDATE_ONLY_GENERATED_HEADER, appIsrCacheKey, appIsrFallbackShellHtmlKey, appIsrFallbackShellKey, appIsrHtmlKey, appIsrRouteKey, appIsrRscKey, buildAppPageCacheValue, buildPagesCacheValue, coalesceOnDemandRevalidation, getRevalidateSecret, isOnDemandRevalidateRequest, isRevalidateSecret, isrCacheControl, isrCacheKey, isrGet, isrSet, isrSetPrerenderedAppPage, normalizeMountedSlotsHeader, pagesIsrCacheKey, resolveRouteExpireSeconds, triggerBackgroundRegeneration };
+export { PRERENDER_REVALIDATE_HEADER, PRERENDER_REVALIDATE_ONLY_GENERATED_HEADER, appIsrCacheKey, appIsrFallbackShellHtmlKey, appIsrFallbackShellKey, appIsrHtmlKey, appIsrRouteKey, appIsrRscKey, buildAppPageCacheValue, buildPagesCacheValue, coalesceOnDemandResponse, coalesceOnDemandRevalidation, getRevalidateSecret, isOnDemandRevalidateRequest, isRevalidateSecret, isrCacheControl, isrCacheKey, isrGet, isrSet, isrSetPrerenderedAppPage, normalizeMountedSlotsHeader, pagesIsrCacheKey, resolveRouteExpireSeconds, triggerBackgroundRegeneration };

package/dist/server/metadata-route-build-data.d.ts

@@ -19,4 +19,5 @@ type MetadataRouteEntryData = {
 export declare function createMetadataRouteEntryData(route: MetadataFileRoute): MetadataRouteEntryData;
 export declare function createMetadataRouteEntrySource(input: MetadataRouteEntrySourceInput): string;
 export declare function createMetadataRouteEntriesSource(routes: readonly MetadataFileRoute[], moduleNames: ReadonlyMap<string, string>): string[];
-//#endregion
+//#endregion
+export {};

package/dist/server/metadata-route-build-data.js

@@ -1,6 +1,6 @@
 import { routePatternParts } from "../routing/route-pattern.js";
 import { getMetadataRouteKind } from "./metadata-routes.js";
-import imageSize from "../deps/.pnpm/image-size@2.0.2/deps/image-size/dist/index.js";
+import { imageSize } from "../deps/.pnpm/image-size@2.0.4/deps/image-size/dist/esm/lookup.js";
 import fs from "node:fs";
 import { createHash } from "node:crypto";
 //#region src/server/metadata-route-build-data.ts

package/dist/server/metadata-route-response.d.ts

@@ -37,4 +37,5 @@ export type PrerenderableMetadataRoute = {
 export declare function getPrerenderableMetadataRoutePaths(metadataRoutes: readonly MetadataRuntimeRoute[]): Promise<PrerenderableMetadataRoute[]>;
 export declare function isMetadataRouteRequestPath(metadataRoutes: readonly MetadataRuntimeRoute[], cleanPathname: string): boolean;
 export declare function handleMetadataRouteRequest(options: MetadataRouteRequestOptions): Promise<Response | null>;
-//#endregion
+//#endregion
+export {};

package/dist/server/metadata-route-response.js

@@ -8,17 +8,17 @@ import { runInWorkStoreScope } from "../shims/internal/work-store-scope.js";
 import { beginRouteCacheability, markRouteCacheabilityExplicitResponsePolicy, markRouteCacheabilityResponseBodyComplete, recordRouteCacheability } from "../shims/cacheability-classification.js";
 import { NEVER_CACHE_CONTROL, applyCdnResponseHeaders, hasCdnResponsePolicy } from "./cache-control.js";
 import { buildAppRouteMissIsrCacheControl } from "./isr-decision.js";
-import { isrCacheControl } from "./isr-cache.js";
+import { coalesceOnDemandResponse, isrCacheControl } from "./isr-cache.js";
 import { resolveClientStaleTimeSeconds } from "../utils/cache-control-metadata.js";
 import { isRenderDynamicLatched } from "../shims/internal/headers-state.js";
 import { getActiveDraftModeState, getHeadersContext, hasDraftModeCookieHeader, replaceHeadersContext } from "../shims/headers.js";
-import { _consumeRequestScopedCacheLife } from "../shims/cache-request-state.js";
+import { _consumeRequestScopedCacheLife, _isOnDemandRevalidate } from "../shims/cache-request-state.js";
 import { ensureFetchPatch, getCollectedFetchTags, setCurrentFetchSoftTags } from "../shims/fetch-cache.js";
 import { isValidMetadataImageId, manifestToJson, matchMetadataRoutePattern, robotsToText, sitemapToXml } from "./metadata-routes.js";
-import { applyPrerenderCacheLifeHeader, applyPrerenderCacheTagsHeader } from "./prerender-cache-life-header.js";
+import { buildAppRouteCacheValue, buildRouteHandlerCachedResponse } from "./app-route-handler-response.js";
 import { canonicalizeAppPageParams } from "./app-page-segment-state.js";
+import { applyPrerenderCacheLifeHeader, applyPrerenderCacheTagsHeader } from "./prerender-cache-life-header.js";
 import { buildPageCacheTags } from "./implicit-tags.js";
-import { buildAppRouteCacheValue, buildRouteHandlerCachedResponse } from "./app-route-handler-response.js";
 import { createStaticGenerationHeadersContext } from "./app-static-generation.js";
 import { completeAppRouteHandlerResponse } from "./app-route-handler-execution.js";
 //#region src/server/metadata-route-response.ts
@@ -165,7 +165,7 @@ async function captureRenderedMetadataRoute(response, route, cleanPathname) {
 		...observedCacheLife,
 		revalidate: frameworkRevalidate
 	};
-	const cacheable = (response.status < 400 || response.status === 404) && completed && !isRenderDynamicLatched() && !getActiveDraftModeState() && !hasDraftModeCookieHeader() && route.module?.dynamic !== "force-dynamic" && frameworkRevalidate > 0 && !response.headers.has("set-cookie");
+	const cacheable = (_isOnDemandRevalidate() || response.status < 400 || response.status === 404) && completed && !isRenderDynamicLatched() && !getActiveDraftModeState() && !hasDraftModeCookieHeader() && route.module?.dynamic !== "force-dynamic" && frameworkRevalidate > 0 && !response.headers.has("set-cookie");
 	const cacheControl = cacheable ? buildAppRouteMissIsrCacheControl(frameworkRevalidate, cacheLife?.expire) : NEVER_CACHE_CONTROL;
 	if (isUserResponse && !hasUserPolicy) {
 		response = new Response(response.body, {
@@ -231,12 +231,34 @@ async function runMetadataRouteRegeneration(options, route, render, routeKey, pr
 		await closeAfterResponse(requestContext);
 	}
 }
+/** The outer ISR key for a matched metadata route, or null if it's never cached. */
+function getOuterMetadataCacheKey(options, route) {
+	if (!isOuterMetadataCacheEnabled() || !options.isrRouteKey || getActiveDraftModeState() || hasDraftModeCookieHeader() || route.module?.dynamic === "force-dynamic" || route.module?.revalidate === 0) return null;
+	return options.isrRouteKey(options.cleanPathname);
+}
+/**
+* Renders a matched metadata route that wasn't served from the cache, and
+* stores it. Concurrent on-demand revalidations of one entry share a single
+* render, as Next.js batches ResponseCache work by its key and
+* isOnDemandRevalidate.
+*/
+async function renderMetadataRouteMiss(options, route, render, cachedEntry) {
+	const renderAndStore = async () => {
+		const rendered = await render();
+		if (!rendered) return null;
+		await writeMetadataRouteMiss(options, route, rendered, cachedEntry);
+		return rendered.response;
+	};
+	const routeKey = _isOnDemandRevalidate() ? getOuterMetadataCacheKey(options, route) : null;
+	if (routeKey === null || !options.isrSet) return renderAndStore();
+	return coalesceOnDemandResponse(routeKey, "GET", renderAndStore);
+}
 async function readMatchedPrerenderedMetadataRouteResponse(options, route, render) {
-	if (!isOuterMetadataCacheEnabled() || !options.isrGet || !options.isrRouteKey || getActiveDraftModeState() || hasDraftModeCookieHeader() || route.module?.dynamic === "force-dynamic" || route.module?.revalidate === 0) return {
+	const routeKey = getOuterMetadataCacheKey(options, route);
+	if (routeKey === null || !options.isrGet || _isOnDemandRevalidate()) return {
 		cachedEntry: null,
 		response: null
 	};
-	const routeKey = options.isrRouteKey(options.cleanPathname);
 	let cached;
 	try {
 		cached = await options.isrGet(routeKey);
@@ -495,11 +517,8 @@ async function handleMetadataRouteRequest(options) {
 					};
 					const cached = await readMatchedPrerenderedMetadataRouteResponse(options, route, render);
 					if (cached.response) return cached.response;
-					const rendered = await render();
-					if (rendered) {
-						await writeMetadataRouteMiss(options, route, rendered, cached.cachedEntry);
-						return rendered.response;
-					}
+					const response = await renderMetadataRouteMiss(options, route, render, cached.cachedEntry);
+					if (response) return response;
 				}
 				continue;
 			}
@@ -533,9 +552,7 @@ async function handleMetadataRouteRequest(options) {
 			});
 			if (dynamicParamsResponse) return dynamicParamsResponse;
 		}
-		const rendered = await render();
-		await writeMetadataRouteMiss(options, route, rendered, cached.cachedEntry);
-		return rendered.response;
+		return renderMetadataRouteMiss(options, route, render, cached.cachedEntry);
 	}
 	return null;
 }

package/dist/server/metadata-routes.d.ts

@@ -155,4 +155,5 @@ export declare function invalidateMetadataFileCache(): void;
  * Scan an app directory for metadata files.
  */
 export declare function scanMetadataFiles(appDir: string): MetadataFileRoute[];
-//#endregion
+//#endregion
+export {};

package/dist/server/middleware-runtime.d.ts

@@ -87,4 +87,5 @@ export declare function resolveMiddlewareModuleHandler(mod: MiddlewareModule, op
 }): MiddlewareHandler;
 export declare function executeMiddleware(options: ExecuteMiddlewareOptions): Promise<MiddlewareResult>;
 export declare function runGeneratedMiddleware(options: RunGeneratedMiddlewareOptions): Promise<MiddlewareResult>;
-//#endregion
+//#endregion
+export {};

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

@@ -1,5 +1,14 @@
 import { CacheabilityRepresentation } from "./cacheability-manifest.js";
 //#region src/server/multi-stage.d.ts
+/**
+ * The origin a shared cache identity names in place of the request's. Next.js
+ * keys its response cache by pathname, so one stored response answers every
+ * host an app serves. `.invalid` never resolves, so no configured domain or
+ * host condition can match it when the identity is replayed.
+ */
+export declare const VINEXT_CACHE_IDENTITY_ORIGIN = "https://cache-identity.vinext.invalid";
+/** Name `origin` in place of a dispatch URL's origin in a shared cache identity. */
+export declare function withCacheIdentityOrigin(requestUrl: string, origin?: string): string;
 /** Whether a response-stage cache must reject a field it did not key itself by. */
 export declare function hasUnsupportedResponseStageVary(headers: Headers, keyedRequestHeaders?: Iterable<string>): boolean;
 /**
@@ -41,26 +50,58 @@ export type VinextResponseStageDispatchOptions = {
    */
   regeneratesStoredEntry?: boolean;
   /**
-   * Query-free identity of a shared App page GET/HEAD dispatch, supplied only
-   * to adapters that declare `responseStageCacheIdentity: "query-free"` and
-   * require completed-response admission. A transport given one partitions
+   * Shared cache identity of an App Router GET/HEAD dispatch, or of a Pages
+   * page the build found static (getStaticProps or none), supplied only to
+   * adapters that declare a `responseStageCacheIdentity` and require
+   * completed-response admission. A transport given one partitions
    * its baseline lookup and stored entry by this request's method and complete
    * URL plus these complete serialized props, instead of the dispatched request
-   * and props, and replays this identity for background regeneration.
+   * and props, and replays this identity for background regeneration, or the
+   * dispatched request and props when `regenerateFromDispatch` is set.
    * Everything else in the contract above still applies.
    *
-   * The identity drops the user query from the URL and `resolvedUrl`, keeping
+   * The identity names `VINEXT_CACHE_IDENTITY_ORIGIN` in place of the
+   * request's origin, in its URL and its `requestOrigin`, so one stored
+   * response answers every host, as Next.js's pathname-keyed response cache
+   * does. That is safe only because completed-response admission refuses a
+   * response whose render used a dynamic API, which every App Router read of
+   * the request's host is. Core omits the identity for bypassed dispatches.
+   *
+   * A Pages page identity instead names the configured i18n domain the
+   * request's host selects, as vinext's Pages ISR key keeps the domain, and
+   * the cache identity origin for every other host. A page without
+   * getStaticProps whose page or `_app` getInitialProps turns out to run is
+   * refused admission, because its props say the entry is shared across
+   * hosts. A getStaticProps page's `_app` getInitialProps shares its entry,
+   * as in Next.js, which keys it by path.
+   *
+   * Under `responseStageCacheIdentity: "query-free"`, an App page identity
+   * also drops the user query from the URL and `resolvedUrl`, keeping
    * framework representation selectors: the `.rsc` suffix, the render mode,
-   * and, for RSC requests only, the one validated `_rsc` value. That is safe only because completed-response
-   * admission refuses a cacheable App page response unless its render proved
-   * it never read `searchParams`. The dispatched request still carries the real
-   * query for the render itself. Core omits the identity when a `next.config`
-   * public cache policy applies (cached per full URL, as Next.js CDN caching
-   * is), and for bypassed, interception, and mounted-slot dispatches.
+   * and, for RSC requests only, the one validated `_rsc` value. That is safe
+   * only because completed-response admission refuses a cacheable App page
+   * response unless its render proved it never read `searchParams`. The
+   * dispatched request still carries the real query for the render itself. A
+   * page identity keeps the query when a `next.config` public cache policy
+   * applies (cached per full URL, as Next.js CDN caching is), and for
+   * interception and mounted-slot dispatches.
    */
   cacheIdentity?: {
     props: unknown;
+    /**
+     * Set when the identity dropped the user query. A transport stores a
+     * page's other part from one render only under such an identity: one
+     * that keeps the query is cached per full URL, and stores its own part.
+     */
+    queryFree?: true;
     request: Request;
+    /**
+     * Regenerate from the dispatched request and props. A getStaticProps
+     * page's custom `_app` getInitialProps receives the request, host
+     * included, so a Pages page regenerates from a real request, as in
+     * Next.js, never from the identity's synthetic origin.
+     */
+    regenerateFromDispatch?: true;
   };
 };
 export type VinextCacheabilityProbeMode = "probe" | "identity";

package/dist/server/multi-stage.js

@@ -1,8 +1,20 @@
 //#region src/server/multi-stage.ts
+/**
+* The origin a shared cache identity names in place of the request's. Next.js
+* keys its response cache by pathname, so one stored response answers every
+* host an app serves. `.invalid` never resolves, so no configured domain or
+* host condition can match it when the identity is replayed.
+*/
+const VINEXT_CACHE_IDENTITY_ORIGIN = "https://cache-identity.vinext.invalid";
+/** Name `origin` in place of a dispatch URL's origin in a shared cache identity. */
+function withCacheIdentityOrigin(requestUrl, origin = VINEXT_CACHE_IDENTITY_ORIGIN) {
+	const url = new URL(requestUrl);
+	return `${origin}${url.pathname}${url.search}`;
+}
 /** Whether a response-stage cache must reject a field it did not key itself by. */
 function hasUnsupportedResponseStageVary(headers, keyedRequestHeaders = []) {
 	const keyedFields = new Set([...keyedRequestHeaders].map((name) => name.trim().toLowerCase()).filter(Boolean));
 	return (headers.get("Vary") ?? "").split(",").map((name) => name.trim().toLowerCase()).filter(Boolean).some((name) => name === "*" || !keyedFields.has(name));
 }
 //#endregion
-export { hasUnsupportedResponseStageVary };
+export { VINEXT_CACHE_IDENTITY_ORIGIN, hasUnsupportedResponseStageVary, withCacheIdentityOrigin };

package/dist/server/navigation-planner.js

@@ -1,9 +1,9 @@
 import { stripBasePath } from "../utils/base-path.js";
 import { splitPathnameForRouteMatch } from "../routing/utils.js";
 import { matchRoutePattern, matchRoutePatternPrefix, matchRoutePatternWithOptionalDynamicSegments } from "../routing/route-pattern.js";
+import { resolveHardNavigationTargetFromRscResponse, resolveRscCompatibilityNavigationDecision } from "./app-rsc-cache-busting.js";
 import { AppElementsWire, compareAppElementsSlotIds } from "./app-elements-wire.js";
 import "./app-elements.js";
-import { resolveHardNavigationTargetFromRscResponse, resolveRscCompatibilityNavigationDecision } from "./app-rsc-cache-busting.js";
 import { resolveRscRedirectLifecycleHop, resolveStreamedRscRedirectLifecycleHop } from "./app-browser-rsc-redirect.js";
 import { NavigationTraceReasonCodes, createNavigationLifecycleTraceFields, createNavigationTrace } from "./navigation-trace.js";
 import { verifyOperationTokenForCacheReuse } from "./operation-token.js";

package/dist/server/navigation-trace.d.ts

@@ -65,4 +65,5 @@ export declare function createNavigationLifecycleTraceFields(options: {
 }): NavigationTraceFields;
 export declare function createNavigationTrace(code: NavigationTraceCode, fields?: NavigationTraceFields): NavigationTrace;
 export declare function prependNavigationTraceEntry(trace: NavigationTrace, code: NavigationTraceCode, fields?: NavigationTraceFields): NavigationTrace;
-//#endregion
+//#endregion
+export {};

package/dist/server/next-error-digest.d.ts

@@ -24,4 +24,5 @@ export declare function parseNextRedirectDigest(digest: string): NextRedirectDig
  * for the fallback form. Returns null otherwise.
  */
 export declare function parseNextHttpErrorDigest(digest: string): NextHttpErrorDigest | null;
-//#endregion
+//#endregion
+export {};

package/dist/server/nitro-public-files-plugin.d.ts

@@ -35,4 +35,5 @@ type NitroPublicFilesPluginOptions = {
   fetchApp(request: Request): Promise<Response>;
 };
 export declare function createNitroPublicFilesPlugin(options: NitroPublicFilesPluginOptions): (nitroApp: NitroApp) => void;
-//#endregion
+//#endregion
+export {};

package/dist/server/nitro-public-files.d.ts

@@ -18,4 +18,5 @@ type PagesWorkerEntry<Env, Context extends object> = {
  * fetcher that reads files through Nitro's static handler.
  */
 export declare function withNitroPagesPublicFiles<Env, Context extends object>(worker: PagesWorkerEntry<Env, Context>): PagesWorkerEntry<Env, Context>;
-//#endregion
+//#endregion
+export {};

package/dist/server/opentelemetry-api.d.ts

@@ -56,4 +56,5 @@ export type OpenTelemetryApi = {
 export declare function getOpenTelemetryRootContext(): OpenTelemetryContext;
 /** Resolve the API registered by the application, if any. */
 export declare function getOpenTelemetryApi(): OpenTelemetryApi | undefined;
-//#endregion
+//#endregion
+export {};

package/dist/server/operation-token.d.ts

@@ -36,4 +36,5 @@ export type OperationTokenVerificationPolicy = {
 export declare function verifyOperationToken(token: OperationToken, authority: OperationTokenAuthority, policy: OperationTokenVerificationPolicy): OperationTokenVerdict;
 export declare function verifyOperationTokenForCommit(token: OperationToken, authority: Pick<OperationTokenAuthority, "activeNavigationId" | "visibleCommitVersion">): OperationTokenVerdict;
 export declare function verifyOperationTokenForCacheReuse(token: OperationToken, authority: Pick<OperationTokenAuthority, "graphVersion" | "installedCacheVariantFingerprint">): OperationTokenVerdict;
-//#endregion
+//#endregion
+export {};

package/dist/server/pages-api-route.d.ts

@@ -85,4 +85,5 @@ type HandlePagesApiRouteOptions = {
   trustedRevalidateOrigin?: string;
 };
 export declare function handlePagesApiRoute(options: HandlePagesApiRouteOptions): Promise<Response>;
-//#endregion
+//#endregion
+export {};

package/dist/server/pages-api-route.js

@@ -30,6 +30,17 @@ function isEdgeApiRouteModule(module) {
 function isNodeApiRouteModule(module) {
 	return typeof module.default === "function" && !isEdgeApiRuntime(resolveModuleRuntime(module));
 }
+function withInitialResponseHeaders(response, initialResponseHeaders) {
+	if (!initialResponseHeaders || !initialResponseHeaders.keys().next().value) return response;
+	const headers = new Headers(initialResponseHeaders);
+	for (const [name, value] of response.headers) if (name !== "set-cookie") headers.set(name, value);
+	for (const cookie of response.headers.getSetCookie()) headers.append("Set-Cookie", cookie);
+	return new Response(response.body, {
+		headers,
+		status: response.status,
+		statusText: response.statusText
+	});
+}
 async function handlePagesApiRoute(options) {
 	const run = async () => {
 		const response = await _handlePagesApiRoute(options);
@@ -51,22 +62,10 @@ async function _handlePagesApiRoute(options) {
 				skipTrailingSlashRedirect: options.nextConfig.skipTrailingSlashRedirect
 			} } : void 0);
 			const response = await tracePagesApiHandler(route.pattern, () => handler(nextRequest));
-			if (response instanceof Response) {
-				const finalized = finalizeEdgeApiResponse(response, options.edgeRuntime ?? "worker");
-				if (!options.initialResponseHeaders || !options.initialResponseHeaders.keys().next().value) return finalized;
-				const headers = new Headers(options.initialResponseHeaders);
-				for (const [name, value] of finalized.headers) if (name.toLowerCase() !== "set-cookie") headers.set(name, value);
-				const finalizedCookies = finalized.headers.getSetCookie();
-				for (const cookie of finalizedCookies) headers.append("Set-Cookie", cookie);
-				return new Response(finalized.body, {
-					headers,
-					status: finalized.status,
-					statusText: finalized.statusText
-				});
-			}
+			if (response instanceof Response) return withInitialResponseHeaders(finalizeEdgeApiResponse(response, options.edgeRuntime ?? "worker"), options.initialResponseHeaders);
 			throw new Error("Edge API route did not return a Response");
 		}
-		if (!isNodeApiRouteModule(route.module)) return new Response("API route does not export a default function", { status: 500 });
+		if (!isNodeApiRouteModule(route.module)) return withInitialResponseHeaders(new Response("API route does not export a default function", { status: 500 }), options.initialResponseHeaders);
 		const handler = route.module.default;
 		const query = buildPagesApiQuery(options.url, params);
 		const bodyParserConfig = resolveBodyParserConfig(route.module.config);
@@ -92,8 +91,12 @@ async function _handlePagesApiRoute(options) {
 			if (!res.writableEnded) markVinextStreamedApiResponse(response);
 			return response;
 		};
-		const destroyAfterHandlerError = (error) => {
+		const settleHandlerError = (error) => {
 			const normalizedError = error instanceof Error ? error : new Error(String(error));
+			if (!res.headersSent) return {
+				type: "error",
+				error: normalizedError
+			};
 			res.destroy(normalizedError);
 			throw normalizedError;
 		};
@@ -101,22 +104,28 @@ async function _handlePagesApiRoute(options) {
 			type: "response",
 			response
 		}));
-		const handlerCompletion = Promise.resolve().then(() => tracePagesApiHandler(route.pattern, () => handler(req, res), { recordErrors: options.edgeRuntime !== "node" })).then(() => ({ type: "handler" }), destroyAfterHandlerError);
+		const handlerCompletion = Promise.resolve().then(() => tracePagesApiHandler(route.pattern, () => handler(req, res), { recordErrors: options.edgeRuntime !== "node" })).then(() => ({ type: "handler" }), settleHandlerError);
 		const firstSettled = await Promise.race([responseReady, handlerCompletion]);
 		if (firstSettled.type === "response") {
 			const handlerLifecycle = handlerCompletion.then(completeHandler, (error) => options.reportRequestError?.(error, route.pattern));
 			getRequestExecutionContext()?.waitUntil(handlerLifecycle);
 			return finalizeResponse(firstSettled.response);
 		}
+		if (firstSettled.type === "error") {
+			await options.reportRequestError?.(firstSettled.error, route.pattern);
+			res.statusCode = 500;
+			res.end("Internal Server Error");
+			return finalizeResponse(await responsePromise);
+		}
 		completeHandler();
 		return finalizeResponse(await responsePromise);
 	} catch (error) {
-		if (error instanceof PagesBodyParseError) return new Response(error.message, {
+		if (error instanceof PagesBodyParseError) return withInitialResponseHeaders(new Response(error.message, {
 			status: error.statusCode,
 			statusText: error.message
-		});
+		}), options.initialResponseHeaders);
 		await options.reportRequestError?.(error instanceof Error ? error : new Error(String(error)), route.pattern);
-		return internalServerErrorResponse();
+		return withInitialResponseHeaders(internalServerErrorResponse(), options.initialResponseHeaders);
 	}
 }
 //#endregion

package/dist/server/pages-asset-tags.d.ts

@@ -81,4 +81,5 @@ type CollectAssetTagsOptions = {
  * Extracted from `entries/pages-server-entry.ts`.
  */
 export declare function collectAssetTags(options: CollectAssetTagsOptions): string;
-//#endregion
+//#endregion
+export {};

package/dist/server/pages-body-parser-config.d.ts

@@ -55,4 +55,5 @@ export declare function resolveBodyParserConfig(moduleConfig: {
     };
   };
 } | undefined, defaultSizeLimit?: number): ResolvedBodyParserConfig;
-//#endregion
+//#endregion
+export {};

package/dist/server/pages-client-assets.d.ts

@@ -1,8 +1,12 @@
+import { ClientReferenceChunks } from "../utils/client-reference-chunks.js";
 //#region src/server/pages-client-assets.d.ts
 export type AssetCrossOrigin = "" | "anonymous" | "use-credentials";
 export type PagesClientAssets = {
   clientEntry?: string;
   appBootstrapPreinitModules?: string[];
+  appRouteManifestModule?: string;
+  /** What each App Router client reference loads in the browser, by URL. */
+  appClientReferenceChunks?: ClientReferenceChunks;
   ssrManifest?: Record<string, string[]>;
   /**
    * Shared Pages chunk files (framework, vinext runtime, client entry) keyed on

package/dist/server/pages-data-route.d.ts

@@ -138,4 +138,5 @@ type NormalizePagesDataRequestResult = {
  * `runMiddleware` share a single implementation.
  */
 export declare function normalizePagesDataRequest(request: Request, buildId: string | null, basePath?: string, trailingSlash?: boolean): NormalizePagesDataRequestResult;
-//#endregion
+//#endregion
+export {};

package/dist/server/pages-document-asset-props.d.ts

@@ -26,4 +26,5 @@ export declare function extractDocumentAssetProps(html: string, token: string):
 export declare function markDocumentAssetPropsProtectedTags(html: string, markerAttribute: string): string;
 export declare function stripDocumentAssetPropsProtectionMarkers(html: string, markerAttribute: string): string;
 export declare function applyDocumentAssetProps(html: string, props: DocumentAssetProps, options?: ApplyDocumentAssetPropsOptions): string;
-//#endregion
+//#endregion
+export {};

package/dist/server/pages-document-initial-props.d.ts

@@ -78,4 +78,5 @@ type RunDocumentRenderPageResult = {
  * @see .nextjs-ref/packages/next/src/server/render.tsx (search `renderPage`)
  */
 export declare function runDocumentRenderPage(input: DocumentRenderPageInput): Promise<RunDocumentRenderPageResult>;
-//#endregion
+//#endregion
+export {};

package/dist/server/pages-execution-tracing.d.ts

@@ -37,4 +37,5 @@ export declare function createFindPageComponentsSpanDescriptor(routePattern: str
   readonly type: "NextNodeServer.findPageComponents";
 };
 export declare function traceFindPageComponents<T>(routePattern: string, callback: () => T): T;
-//#endregion
+//#endregion
+export {};

package/dist/server/pages-execution-tracing.js

@@ -1,6 +1,6 @@
+import { deferUntilStreamConsumed } from "./defer-until-stream-consumed.js";
 import { patternToNextFormat } from "../routing/route-validation.js";
 import { frameworkTracer } from "./tracer.js";
-import { deferUntilStreamConsumed } from "./defer-until-stream-consumed.js";
 //#region src/server/pages-execution-tracing.ts
 function createPagesDataSpanDescriptor(method, routePattern) {
 	const route = patternToNextFormat(routePattern);

package/dist/server/pages-get-initial-props.d.ts

@@ -76,4 +76,5 @@ export type DevAppInitialPropsContext = {
  * data code does not run on the cache hot path.
  */
 export declare function loadDevAppInitialProps(ctx: DevAppInitialPropsContext): Promise<DevAppInitialPropsResult>;
-//#endregion
+//#endregion
+export {};