@qzsy/vinext 0.1.12 → 0.1.80

package/dist/server/image-optimization.js

@@ -95,7 +95,8 @@ function parseImageParams(url, allowedWidths = [...DEFAULT_DEVICE_SIZES, ...DEFA
 	const allowedParamNames = new Set([
 		"url",
 		"w",
-		"q"
+		"q",
+		"dpl"
 	]);
 	for (const name of url.searchParams.keys()) if (!allowedParamNames.has(name) || url.searchParams.getAll(name).length !== 1) return null;
 	const imageUrl = url.searchParams.get("url");
@@ -243,5 +244,54 @@ async function handleImageOptimization(request, handlers, allowedWidths, imageCo
 		return createPassthroughImageResponse(refetchedSource, imageConfig);
 	}
 }
+const _IMAGE_OPTIMIZER_KEY = Symbol.for("vinext.imageOptimizer");
+const _gImageOptimizer = globalThis;
+/**
+* Register the active image optimizer (transform backend). An explicit
+* registration always wins; passing `null` clears it (falling back to
+* unoptimized passthrough).
+*
+* Configure this declaratively via the `images.optimizer` option on the
+* `vinext()` plugin in your `vite.config.ts` rather than calling it directly.
+* On Cloudflare Workers:
+*
+* ```ts
+* import { vinext } from "vinext";
+* import { imagesOptimizer } from "@vinext/cloudflare/images/images-optimizer";
+*
+* export default defineConfig({
+*   plugins: [vinext({ images: { optimizer: imagesOptimizer() } })],
+* });
+* ```
+*
+* The plugin registers the optimizer across every runtime/router entry, so you
+* don't have to wire `env.IMAGES` into a custom worker entry. This setter
+* remains the internal registration target.
+*/
+function setImageOptimizer(optimizer) {
+	_gImageOptimizer[_IMAGE_OPTIMIZER_KEY] = optimizer ?? void 0;
+}
+/** Get the active image optimizer, or `null` when none is configured. */
+function getImageOptimizer() {
+	return _gImageOptimizer[_IMAGE_OPTIMIZER_KEY] ?? null;
+}
+/**
+* Handle an image optimization request using the configured optimizer (if any).
+*
+* This is the single entry point every runtime/router seam (App Router worker,
+* Pages worker, Node prod server) should call: it reads the registered
+* {@link ImageOptimizer} and wires its `transformImage` into
+* {@link handleImageOptimization}, with the caller supplying the runtime's
+* `fetchAsset` (e.g. the Cloudflare `ASSETS` binding, or filesystem reads on
+* Node). When no optimizer is registered, the request is served unoptimized
+* (passthrough) with the same security/cache headers.
+*/
+function handleConfiguredImageOptimization(request, fetchAsset, allowedWidths, imageConfig) {
+	const optimizer = getImageOptimizer();
+	return handleImageOptimization(request, {
+		fetchAsset,
+		transformImage: optimizer ? (body, options) => optimizer.transformImage(body, options) : void 0
+	}, allowedWidths, imageConfig);
+}
 //#endregion
-export { DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES, IMAGE_CACHE_CONTROL, IMAGE_CONTENT_SECURITY_POLICY, IMAGE_OPTIMIZATION_PATH, VINEXT_IMAGE_OPTIMIZATION_PATH, handleImageOptimization, isImageOptimizationPath, isSafeImageContentType, negotiateImageFormat, parseImageParams, resolveDevImageRedirect, snapToNearestAllowedWidth };
+export { DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES, IMAGE_CACHE_CONTROL, IMAGE_CONTENT_SECURITY_POLICY, IMAGE_OPTIMIZATION_PATH, VINEXT_IMAGE_OPTIMIZATION_PATH, getImageOptimizer, handleConfiguredImageOptimization, handleImageOptimization, isImageOptimizationPath, isSafeImageContentType, negotiateImageFormat, parseImageParams, resolveDevImageRedirect, setImageOptimizer, snapToNearestAllowedWidth };

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

@@ -95,7 +95,7 @@ declare function buildPagesCacheValue(html: string, pageData: object, status?: n
 /**
  * Build a CachedAppPageValue for the App Router ISR cache.
  */
-declare function buildAppPageCacheValue(html: string, rscData?: ArrayBuffer, status?: number, renderObservation?: RenderObservation): CachedAppPageValue;
+declare function buildAppPageCacheValue(html: string, rscData?: ArrayBuffer, status?: number, renderObservation?: RenderObservation, headers?: CachedAppPageValue["headers"]): CachedAppPageValue;
 /**
  * Compute an ISR cache key for a given router type and pathname.
  * Long pathnames are hashed to stay within KV key-length limits (512 bytes).

package/dist/server/isr-cache.js

@@ -188,12 +188,12 @@ function buildPagesCacheValue(html, pageData, status) {
 /**
 * Build a CachedAppPageValue for the App Router ISR cache.
 */
-function buildAppPageCacheValue(html, rscData, status, renderObservation) {
+function buildAppPageCacheValue(html, rscData, status, renderObservation, headers) {
 	const value = {
 		kind: "APP_PAGE",
 		html,
 		rscData,
-		headers: void 0,
+		headers,
 		postponed: void 0,
 		status
 	};

package/dist/server/middleware-runtime.js

@@ -2,8 +2,9 @@ import { normalizePathnameForRouteMatchStrict } from "../routing/utils.js";
 import { addBasePathToPathname, hasBasePath, removeTrailingSlash, stripBasePath } from "../utils/base-path.js";
 import "./server-globals.js";
 import { getRequestExecutionContext, runWithExecutionContext } from "../shims/request-context.js";
+import "../utils/protocol-headers.js";
 import { MIDDLEWARE_REWRITE_HEADER } from "./headers.js";
-import { shouldKeepMiddlewareHeader } from "./middleware-request-headers.js";
+import { shouldKeepMiddlewareHeader } from "../utils/middleware-request-headers.js";
 import { NextFetchEvent, NextRequest } from "../shims/server.js";
 import { normalizePath } from "./normalize-path.js";
 import { matchesMiddleware } from "./middleware-matcher.js";
@@ -141,6 +142,10 @@ async function executeMiddleware(options) {
 	const matchPathname = options.basePath ? stripBasePath(normalizedPathname, options.basePath) : normalizedPathname;
 	if (!matchesMiddleware(matchPathname, middlewareMatcher(options.module), options.request, options.i18nConfig)) return { continue: true };
 	const nextRequest = createNextRequest(options.request, normalizedPathname, options.i18nConfig, options.basePath, options.trailingSlash, hadBasePath);
+	if (options.isDataRequest) Object.defineProperty(nextRequest, "__isData", {
+		enumerable: false,
+		value: true
+	});
 	const fetchEvent = new NextFetchEvent({ page: removeTrailingSlash(matchPathname) });
 	let response;
 	try {

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

@@ -103,6 +103,7 @@ type NavigationDecision = {
 type FlightResult = {
   cacheEntryReuseProof?: CacheEntryReuseProof;
   href: string;
+  restoredHistorySnapshot?: boolean;
   targetSnapshot: RouteSnapshot;
 };
 type RscFetchResultSource = "cached" | "live";

package/dist/server/navigation-planner.js

@@ -1,8 +1,8 @@
 import { splitPathnameForRouteMatch } from "../routing/utils.js";
 import { stripBasePath } from "../utils/base-path.js";
-import { matchRoutePattern, matchRoutePatternPrefix, matchRoutePatternWithOptionalDynamicSegments } from "../routing/route-pattern.js";
 import { compareAppElementsSlotIds } from "./app-elements-wire.js";
 import "./app-elements.js";
+import { matchRoutePattern, matchRoutePatternPrefix, matchRoutePatternWithOptionalDynamicSegments } from "../routing/route-pattern.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";
@@ -291,6 +291,11 @@ function stripInterceptionContextFromRouteId(routeId) {
 	const separatorIndex = routeId.indexOf(ROUTE_INTERCEPTION_CONTEXT_SEPARATOR);
 	return separatorIndex === -1 ? routeId : routeId.slice(0, separatorIndex);
 }
+function matchedUrlFromConcreteRouteId(routeId) {
+	const normalizedRouteId = stripInterceptionContextFromRouteId(routeId);
+	if (!normalizedRouteId.startsWith("route:/")) return null;
+	return normalizedRouteId.slice(6);
+}
 function getMatchedUrlPathname(matchedUrl) {
 	try {
 		return new URL(matchedUrl, "https://vinext.local").pathname;
@@ -315,6 +320,11 @@ function findRouteManifestRouteByIdOrMatchedUrl(options) {
 	const routeId = stripInterceptionContextFromRouteId(options.routeId);
 	const route = options.routeManifest.segmentGraph.routes.get(routeId);
 	if (route && routeManifestRouteMatchesUrl(route, options.matchedUrl)) return route;
+	const concreteRouteMatchedUrl = route === void 0 ? matchedUrlFromConcreteRouteId(options.routeId) : null;
+	if (concreteRouteMatchedUrl !== null) {
+		const concreteRoute = findRouteManifestRouteByMatchedUrl(options.routeManifest, concreteRouteMatchedUrl);
+		if (concreteRoute !== null) return concreteRoute;
+	}
 	return findRouteManifestRouteByMatchedUrl(options.routeManifest, options.matchedUrl);
 }
 function findRouteManifestRouteForSnapshot(routeManifest, snapshot) {
@@ -480,7 +490,7 @@ function getVisibleInterceptionSourceIdentity(snapshot) {
 		routeId: snapshot.interception.sourceRouteId
 	};
 	return {
-		matchedUrl: snapshot.matchedUrl,
+		matchedUrl: matchedUrlFromConcreteRouteId(snapshot.routeId) ?? snapshot.matchedUrl,
 		routeId: snapshot.routeId
 	};
 }
@@ -567,7 +577,7 @@ function validateInterceptedPreservation(options) {
 		reasonCode: NavigationTraceReasonCodes.interceptedRejectedTargetMismatch
 	};
 	const sourceIdentity = getVisibleInterceptionSourceIdentity(options.currentSnapshot);
-	if (proof.sourceMatchedUrl !== sourceIdentity.matchedUrl || proof.sourceRouteId !== sourceIdentity.routeId) return {
+	if (!options.restoredHistorySnapshot && (proof.sourceMatchedUrl !== sourceIdentity.matchedUrl || proof.sourceRouteId !== sourceIdentity.routeId)) return {
 		kind: "rejected",
 		reasonCode: NavigationTraceReasonCodes.interceptedRejectedUnknownSource
 	};
@@ -654,6 +664,7 @@ function planFlightResponseArrived(options) {
 		const validation = validateInterceptedPreservation({
 			currentSnapshot: options.state.visibleSnapshot,
 			currentTopology: currentTopology.topology,
+			restoredHistorySnapshot: options.event.result.restoredHistorySnapshot === true,
 			routeManifest: options.routeManifest,
 			targetSnapshot,
 			targetTopology: targetTopology.topology

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

@@ -10,9 +10,8 @@
  * template string.
  */
 /**
- * Resolve the effective SSR manifest: prefer the caller-supplied object (dev
- * or test) and fall back to the Worker-embedded `globalThis.__VINEXT_SSR_MANIFEST__`
- * injected by `vinext:cloudflare-build` at build time.
+ * Resolve the effective SSR manifest: prefer the caller-supplied object and
+ * fall back to the registered client build metadata.
  */
 declare function resolveSsrManifest(manifest: Record<string, string[]> | null | undefined): Record<string, string[]> | null;
 /**
@@ -34,7 +33,7 @@ declare function resolveClientModuleUrl(manifest: Record<string, string[]> | nul
 type CollectAssetTagsOptions = {
   /**
    * SSR manifest mapping module file paths to their associated asset list.
-   * When empty/null the Worker-embedded `__VINEXT_SSR_MANIFEST__` is used.
+   * When empty/null the registered client build manifest is used.
    */
   manifest: Record<string, string[]> | null | undefined;
   /**
@@ -66,8 +65,7 @@ type CollectAssetTagsOptions = {
  * - CSS files → `<link rel="stylesheet">`.
  * - JS files → `<link rel="modulepreload">` + `<script type="module" defer>`.
  * - Lazy chunks (behind `React.lazy` / `next/dynamic`) are skipped.
- * - The Worker-embedded client-entry bootstrap (`__VINEXT_CLIENT_ENTRY__`) is
- *   injected first so hydration starts as early as possible.
+ * - The registered client-entry bootstrap is injected first.
  * - Shared framework / vinext runtime chunks are always included alongside
  *   page-specific chunks.
  *

package/dist/server/pages-asset-tags.js

@@ -1,6 +1,7 @@
 import { appendDeploymentIdQuery } from "../utils/deployment-id.js";
 import { createNonceAttribute } from "./html.js";
 import { assetServingUrlFromBaseAnchored } from "../utils/manifest-paths.js";
+import { getPagesClientAssets } from "./pages-client-assets.js";
 //#region src/server/pages-asset-tags.ts
 /**
 * Pages Router SSR asset-tag helpers.
@@ -13,13 +14,12 @@ import { assetServingUrlFromBaseAnchored } from "../utils/manifest-paths.js";
 * template string.
 */
 /**
-* Resolve the effective SSR manifest: prefer the caller-supplied object (dev
-* or test) and fall back to the Worker-embedded `globalThis.__VINEXT_SSR_MANIFEST__`
-* injected by `vinext:cloudflare-build` at build time.
+* Resolve the effective SSR manifest: prefer the caller-supplied object and
+* fall back to the registered client build metadata.
 */
 function resolveSsrManifest(manifest) {
 	if (manifest && Object.keys(manifest).length > 0) return manifest;
-	return (typeof globalThis !== "undefined" ? globalThis.__VINEXT_SSR_MANIFEST__ : null) ?? null;
+	return getPagesClientAssets().ssrManifest ?? null;
 }
 /**
 * Look up the asset-file list for a module ID in the SSR manifest.
@@ -58,8 +58,7 @@ function resolveClientModuleUrl(manifest, moduleId, basePath = "", assetPrefix =
 * - CSS files → `<link rel="stylesheet">`.
 * - JS files → `<link rel="modulepreload">` + `<script type="module" defer>`.
 * - Lazy chunks (behind `React.lazy` / `next/dynamic`) are skipped.
-* - The Worker-embedded client-entry bootstrap (`__VINEXT_CLIENT_ENTRY__`) is
-*   injected first so hydration starts as early as possible.
+* - The registered client-entry bootstrap is injected first.
 * - Shared framework / vinext runtime chunks are always included alongside
 *   page-specific chunks.
 *
@@ -77,13 +76,14 @@ function collectAssetTags(options) {
 		const url = assetServingUrlFromBaseAnchored(value, basePath, assetPrefix);
 		return value.endsWith(".js") ? url : appendDeploymentIdQuery(url, options.deploymentId);
 	};
-	const lazyChunks = typeof globalThis !== "undefined" && globalThis.__VINEXT_LAZY_CHUNKS__ || null;
+	const runtimeAssets = getPagesClientAssets();
+	const lazyChunks = runtimeAssets.lazyChunks ?? null;
 	const lazySet = lazyChunks && lazyChunks.length > 0 ? new Set(lazyChunks) : null;
-	if (typeof globalThis !== "undefined" && globalThis.__VINEXT_CLIENT_ENTRY__) {
-		const entry = globalThis.__VINEXT_CLIENT_ENTRY__;
-		seen.add(entry);
-		tags.push("<link rel=\"modulepreload\"" + nonceAttr + " href=\"" + href(entry) + "\" />");
-		tags.push("<script type=\"module\"" + deferAttr + nonceAttr + " src=\"" + href(entry) + "\" crossorigin><\/script>");
+	const clientEntry = runtimeAssets.clientEntry;
+	if (clientEntry) {
+		seen.add(clientEntry);
+		tags.push("<link rel=\"modulepreload\"" + nonceAttr + " href=\"" + href(clientEntry) + "\" />");
+		tags.push("<script type=\"module\"" + deferAttr + nonceAttr + " src=\"" + href(clientEntry) + "\" crossorigin><\/script>");
 	}
 	if (m) {
 		const allFiles = [];

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

@@ -0,0 +1,12 @@
+//#region src/server/pages-client-assets.d.ts
+type PagesClientAssets = {
+  clientEntry?: string;
+  appBootstrapPreinitModules?: string[];
+  ssrManifest?: Record<string, string[]>;
+  lazyChunks?: string[];
+  dynamicPreloads?: Record<string, string[]>;
+};
+declare function setPagesClientAssets(assets: PagesClientAssets | undefined): void;
+declare function getPagesClientAssets(): PagesClientAssets;
+//#endregion
+export { PagesClientAssets, getPagesClientAssets, setPagesClientAssets };

package/dist/server/pages-client-assets.js

@@ -0,0 +1,10 @@
+//#region src/server/pages-client-assets.ts
+let pagesClientAssets = {};
+function setPagesClientAssets(assets) {
+	pagesClientAssets = assets ?? {};
+}
+function getPagesClientAssets() {
+	return pagesClientAssets;
+}
+//#endregion
+export { getPagesClientAssets, setPagesClientAssets };

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

@@ -217,7 +217,29 @@ type ResolvePagesPageDataNotFoundResult = {
   kind: "notFound";
 };
 type ResolvePagesPageDataResult = ResolvePagesPageDataRenderResult | ResolvePagesPageDataResponseResult | ResolvePagesPageDataNotFoundResult;
+/**
+ * Compare a `getStaticPaths` entry against the actual request params.
+ *
+ * Handles both shapes Next.js allows:
+ *   - { params: { ... } }
+ *   - "string-path"
+ *
+ * For a string entry, compare the entry against the current request URL using
+ * the shared `normalizeStaticPathname` helper from
+ * `../routing/route-pattern.ts` (which mirrors the Next.js
+ * `removeTrailingSlash` behaviour in
+ * `.nextjs-ref/packages/next/src/build/static-paths/pages.ts`). For an object
+ * entry with a missing `params` key, return false rather than throwing — the
+ * caller will respond with a 404 just like Next.js does for unlisted paths.
+ */
+type PagesRouteParam = {
+  key: string;
+  repeat: boolean;
+  optional: boolean;
+};
+declare function getPagesRouteParams(routePattern: string): PagesRouteParam[];
+declare function matchesPagesStaticPath(pathEntry: PagesStaticPathsEntry, params: Record<string, unknown>, routeParams: PagesRouteParam[], routeUrl: string): boolean;
 declare function renderPagesIsrHtml(options: RenderPagesIsrHtmlOptions): Promise<string>;
 declare function resolvePagesPageData(options: ResolvePagesPageDataOptions): Promise<ResolvePagesPageDataResult>;
 //#endregion
-export { PagesPageModule, ResolvePagesPageDataOptions, renderPagesIsrHtml, resolvePagesPageData };
+export { PagesPageModule, PagesRouteParam, PagesStaticPathsEntry, ResolvePagesPageDataOptions, getPagesRouteParams, matchesPagesStaticPath, renderPagesIsrHtml, resolvePagesPageData };

package/dist/server/pages-page-data.js

@@ -1,15 +1,15 @@
 import { NEXTJS_DEPLOYMENT_ID_HEADER } from "./headers.js";
-import { normalizeStaticPathname } from "../routing/route-pattern.js";
 import { buildCacheStateHeaders } from "./cache-headers.js";
 import { isUnknownRecord } from "../utils/record.js";
 import { applyCdnResponseHeaders } from "./cache-control.js";
 import { decideIsr } from "./isr-decision.js";
 import { buildPagesCacheValue } from "./isr-cache.js";
-import { isSerializableProps } from "./pages-serializable-props.js";
+import { normalizeStaticPathname } from "../routing/route-pattern.js";
+import { buildPagesNextDataScript, etagMatches, generatePagesETag, isPagesStreamingBot, requestsNoCache } from "./pages-page-response.js";
 import { hasPagesGetInitialProps, isResponseSent, loadPagesGetInitialProps } from "./pages-get-initial-props.js";
-import { isBotUserAgent } from "../utils/html-limited-bots.js";
 import { buildNextDataPropsJsonResponse } from "./pages-data-route.js";
-import { buildPagesNextDataScript, etagMatches, generatePagesETag, isPagesStreamingBot, requestsNoCache } from "./pages-page-response.js";
+import { isSerializableProps } from "./pages-serializable-props.js";
+import { isBotUserAgent } from "../utils/html-limited-bots.js";
 //#region src/server/pages-page-data.ts
 function buildPagesDataNotFoundResponse(deploymentId) {
 	const headers = { "Content-Type": "application/json" };
@@ -128,28 +128,45 @@ function buildPagesRedirectResponse(redirect, options, props = { pageProps: {} }
 		headers: { Location: destination }
 	});
 }
-/**
-* Compare a `getStaticPaths` entry against the actual request params.
-*
-* Handles both shapes Next.js allows:
-*   - { params: { ... } }
-*   - "string-path"
-*
-* For a string entry, compare the entry against the current request URL using
-* the shared `normalizeStaticPathname` helper from
-* `../routing/route-pattern.ts` (which mirrors the Next.js
-* `removeTrailingSlash` behaviour in
-* `.nextjs-ref/packages/next/src/build/static-paths/pages.ts`). For an object
-* entry with a missing `params` key, return false rather than throwing — the
-* caller will respond with a 404 just like Next.js does for unlisted paths.
-*/
-function matchesPagesStaticPath(pathEntry, params, routeUrl) {
+function getPagesRouteParams(routePattern) {
+	return routePattern.split("/").map((segment) => {
+		const optionalCatchAll = segment.match(/^\[\[\.\.\.(.+)\]\]$/);
+		if (optionalCatchAll) return {
+			key: optionalCatchAll[1],
+			repeat: true,
+			optional: true
+		};
+		const requiredCatchAll = segment.match(/^\[\.\.\.(.+)\]$/);
+		if (requiredCatchAll) return {
+			key: requiredCatchAll[1],
+			repeat: true,
+			optional: false
+		};
+		const dynamic = segment.match(/^\[(.+)\]$/);
+		if (dynamic) return {
+			key: dynamic[1],
+			repeat: false,
+			optional: false
+		};
+		return null;
+	}).filter((param) => param !== null);
+}
+function matchesPagesStaticPath(pathEntry, params, routeParams, routeUrl) {
 	if (typeof pathEntry === "string") return normalizeStaticPathname(pathEntry) === normalizeStaticPathname(routeUrl);
 	const entryParams = pathEntry.params;
 	if (entryParams === void 0 || entryParams === null) return false;
-	return Object.entries(entryParams).every(([key, value]) => {
+	return routeParams.every(({ key, repeat, optional }) => {
+		if (!Object.hasOwn(entryParams, key)) return false;
+		let value = entryParams[key];
+		if (optional && (value === null || value === void 0 || value === false)) value = [];
+		if (repeat) {
+			if (!Array.isArray(value) || !optional && value.length === 0) return false;
+		} else if (typeof value !== "string") return false;
 		const actual = params[key];
-		if (Array.isArray(value)) return Array.isArray(actual) && value.join("/") === actual.join("/");
+		if (Array.isArray(value)) {
+			if (optional && value.length === 0 && actual === void 0) return true;
+			return Array.isArray(actual) && value.join("/") === actual.join("/");
+		}
 		return String(value) === String(actual);
 	});
 }
@@ -237,7 +254,9 @@ async function resolvePagesPageData(options) {
 			defaultLocale: options.i18n.defaultLocale ?? ""
 		});
 		const fallback = pathsResult?.fallback ?? false;
-		const isValidPath = (pathsResult?.paths ?? []).some((pathEntry) => matchesPagesStaticPath(pathEntry, options.params, options.routeUrl));
+		const paths = pathsResult?.paths ?? [];
+		const routeParams = getPagesRouteParams(options.routePattern);
+		const isValidPath = paths.some((pathEntry) => matchesPagesStaticPath(pathEntry, options.params, routeParams, options.routeUrl));
 		if (fallback === false && !isValidPath) return buildPagesNotFoundResult(options);
 		const isBotRequest = !!options.userAgent && isBotUserAgent(options.userAgent, options.htmlLimitedBots);
 		if (fallback === true && !isValidPath && !options.isDataReq && !isBotRequest) isFallback = true;
@@ -481,4 +500,4 @@ async function resolvePagesPageData(options) {
 	};
 }
 //#endregion
-export { renderPagesIsrHtml, resolvePagesPageData };
+export { getPagesRouteParams, matchesPagesStaticPath, renderPagesIsrHtml, resolvePagesPageData };

package/dist/server/pages-page-handler.d.ts

@@ -35,6 +35,7 @@ type VinextConfigSubset = {
   clientTraceMetadata?: readonly string[];
   disableOptimizedLoading: boolean;
 };
+declare function shouldEmitPagesClientTraceMetadata(pageModule: PagesPageModule, appComponent: unknown): boolean;
 /**
  * Options accepted by `createPagesPageHandler`.
  *
@@ -97,4 +98,4 @@ type RenderPageOptions = {
  */
 declare function createPagesPageHandler(opts: CreatePagesPageHandlerOptions): (request: Request, url: string, manifest: Record<string, string[]> | null | undefined, middlewareHeaders: Headers | null | undefined, options: RenderPageOptions | null | undefined) => Promise<Response>;
 //#endregion
-export { CreatePagesPageHandlerOptions, createPagesPageHandler };
+export { CreatePagesPageHandlerOptions, createPagesPageHandler, shouldEmitPagesClientTraceMetadata };

package/dist/server/pages-page-handler.js

@@ -14,12 +14,18 @@ import { resolvePagesI18nRequest } from "./pages-i18n.js";
 import { buildDefaultPagesNotFoundResponse } from "./pages-default-404.js";
 import { buildPagesReadinessNextData } from "./pages-readiness.js";
 import { resolvePagesPageMethodResponse } from "./pages-page-method.js";
+import { renderPagesPageResponse } from "./pages-page-response.js";
+import { hasPagesGetInitialProps } from "./pages-get-initial-props.js";
 import { buildNextDataNotFoundResponse, buildNextDataPropsJsonResponse, normalizePagesDataRequest, parseNextDataPathname } from "./pages-data-route.js";
+import { resolvePagesPageData } from "./pages-page-data.js";
 import { createPagesReqRes } from "./pages-node-compat.js";
 import { collectAssetTags, resolveClientModuleUrl } from "./pages-asset-tags.js";
-import { renderPagesPageResponse } from "./pages-page-response.js";
-import { resolvePagesPageData } from "./pages-page-data.js";
 //#region src/server/pages-page-handler.ts
+function shouldEmitPagesClientTraceMetadata(pageModule, appComponent) {
+	if (typeof pageModule.getServerSideProps === "function") return true;
+	if (typeof pageModule.getStaticProps === "function") return false;
+	return hasPagesGetInitialProps(pageModule.default) || hasPagesGetInitialProps(appComponent);
+}
 function buildI18nRenderContext(i18nConfig, locale, currentDefaultLocale, domainLocales) {
 	return {
 		locale,
@@ -334,7 +340,7 @@ function createPagesPageHandler(opts) {
 					getFontLinks,
 					getFontStyles,
 					getSSRHeadHTML: typeof getSSRHeadHTML === "function" ? getSSRHeadHTML : void 0,
-					clientTraceMetadata: vinextConfig.clientTraceMetadata,
+					clientTraceMetadata: shouldEmitPagesClientTraceMetadata(pageModule, AppComponent) ? vinextConfig.clientTraceMetadata : void 0,
 					gsspRes,
 					isrCacheKey: pageIsrCacheKey,
 					expireSeconds: vinextConfig.expireTime,
@@ -400,4 +406,4 @@ function createPagesPageHandler(opts) {
 	return renderPage;
 }
 //#endregion
-export { createPagesPageHandler };
+export { createPagesPageHandler, shouldEmitPagesClientTraceMetadata };

package/dist/server/pages-request-pipeline.d.ts

@@ -34,11 +34,13 @@ type PagesPipelineDeps = {
   hadBasePath: boolean;
   isDataReq: boolean;
   isDataRequest: boolean;
+  hasMiddleware: boolean;
   ctx?: unknown;
   rawSearch?: string;
   matchPageRoute?: ((pathname: string, request: Request) => {
     route: {
       isDynamic: boolean;
+      pattern?: string;
     };
   } | null) | null;
   runMiddleware?: ((request: Request, ctx: unknown, opts: {

package/dist/server/pages-request-pipeline.js

@@ -1,4 +1,5 @@
 import { addBasePathToPathname, hasBasePath } from "../utils/base-path.js";
+import { patternToNextFormat } from "../routing/route-validation.js";
 import { applyMiddlewareRequestHeaders, isExternalUrl, matchRedirect, matchRewrite, preserveRedirectDestinationQuery, proxyExternalRequest, requestContextFromRequest, sanitizeDestination } from "../config/config-matchers.js";
 import { applyConfigHeadersToHeaderRecord, cloneRequestWithUrl, normalizeTrailingSlash } from "./request-pipeline.js";
 import { mergeRewriteQuery } from "../utils/query.js";
@@ -141,6 +142,13 @@ async function runPagesRequest(request, deps) {
 	});
 	let resolvedPathname = pathnameForResolvedUrl(resolvedUrl);
 	const matchResolvedPathname = (p) => i18nConfig ? normalizeDefaultLocalePathname(p, i18nConfig, { hostname: requestHostname }) : p;
+	const matchedPathnameForRoute = (routePattern) => {
+		const matchedPathname = routePattern ? patternToNextFormat(routePattern) : resolvedPathname;
+		if (!i18nConfig) return matchedPathname;
+		const resolvedLocale = resolvedPathname.split("/", 3)[1];
+		if (resolvedLocale && i18nConfig.locales.includes(resolvedLocale)) return matchedPathname === "/" ? `/${resolvedLocale}` : `/${resolvedLocale}${matchedPathname}`;
+		return matchResolvedPathname(matchedPathname);
+	};
 	if (configHeaders.length) applyConfigHeadersToHeaderRecord(middlewareHeaders, {
 		configHeaders,
 		pathname: matchPathname,
@@ -268,12 +276,28 @@ async function runPagesRequest(request, deps) {
 			if (fallbackFilesystemResult) return fallbackFilesystemResult;
 			const fallbackApiResult = await handleResolvedApiRoute();
 			if (fallbackApiResult) return fallbackApiResult;
+			renderPageMatch = deps.matchPageRoute ? deps.matchPageRoute(resolvedPathname, request) : null;
 			response = await deps.renderPage(request, resolvedUrl, void 0, stagedHeaders);
 			matchedFallbackRewrite = true;
 			if (response.status !== 404) break;
 		}
 		if (response.status === 404 && shouldDeferErrorPageOnMiss && !matchedFallbackRewrite) response = await deps.renderPage(request, resolvedUrl, void 0, stagedHeaders);
-		const merged = mergeHeaders(response, middlewareHeaders, middlewareStatus);
+		const matchedPathHeaders = { ...middlewareHeaders };
+		if ((isDataReq || isDataRequest) && deps.hasMiddleware && !renderPageMatch && response.status === 404 && (middlewareStatus === void 0 || middlewareStatus === 200 || middlewareStatus === 404)) {
+			const headers = new Headers(response.headers);
+			headers.set("content-type", "application/json");
+			headers.set("x-nextjs-matched-path", matchResolvedPathname(pathname));
+			return {
+				type: "response",
+				response: mergeHeaders(new Response("{}", {
+					status: 200,
+					headers
+				}), matchedPathHeaders, void 0),
+				defaultContentType: "application/json"
+			};
+		}
+		if ((isDataReq || isDataRequest) && renderPageMatch && (middlewareStatus ?? response.status) === 200) matchedPathHeaders["x-nextjs-matched-path"] = matchedPathnameForRoute(renderPageMatch?.route.pattern);
+		const merged = mergeHeaders(response, matchedPathHeaders, middlewareStatus);
 		if (merged !== response) merged.__vinextStreamedHtmlResponse = response.__vinextStreamedHtmlResponse;
 		return {
 			type: "response",

package/dist/server/prerender-manifest.d.ts

@@ -7,11 +7,13 @@ type PrerenderManifestRoute = {
   path?: string;
   router?: string;
   fallback?: boolean;
+  headers?: Record<string, string>;
 };
 type PrerenderManifest = {
   buildId?: string;
   trailingSlash?: boolean;
   routes?: PrerenderManifestRoute[];
+  pregeneratedConcretePaths?: Array<[string, string[]]>;
 };
 declare function readPrerenderManifest(manifestPath: string): PrerenderManifest | null;
 declare function getRenderedAppRoutes(routes: PrerenderManifestRoute[]): PrerenderManifestRoute[];
@@ -30,4 +32,4 @@ declare function isFallbackShellArtifactPath(pathname: string, route?: Prerender
  */
 declare function buildPregeneratedConcretePathTable(manifest: PrerenderManifest): Array<[string, string[]]>;
 //#endregion
-export { buildPregeneratedConcretePathTable, getRenderedAppRoutes, isFallbackShellArtifactPath, readPrerenderManifest };
+export { PrerenderManifest, buildPregeneratedConcretePathTable, getRenderedAppRoutes, isFallbackShellArtifactPath, readPrerenderManifest };

package/dist/server/prerender-route-params.js

@@ -1,4 +1,4 @@
-import { VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, VINEXT_PRERENDER_SECRET_HEADER } from "./headers.js";
+import { VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, VINEXT_PRERENDER_SECRET_HEADER } from "../utils/protocol-headers.js";
 import { isUnknownRecord } from "../utils/record.js";
 //#region src/server/prerender-route-params.ts
 function isPrerenderRouteParams(value) {

package/dist/server/prod-server.d.ts

@@ -74,7 +74,7 @@ declare function mergeResponseHeaders(middlewareHeaders: Record<string, string |
  * arguments in (headers, response) order. The request path now calls
  * `runPagesRequest`, which uses `mergeHeaders` directly; this wrapper is retained
  * only for its existing tests and any external callers, so there is a single
- * implementation to keep in sync. (deploy.ts still emits its own generated copy.)
+ * implementation to keep in sync. The init-owned Cloudflare Worker template delegates here.
  */
 declare function mergeWebResponse(middlewareHeaders: Record<string, string | string[]>, response: Response, statusOverride?: number): Response;
 /**