vinext 0.1.1 → 0.1.2

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

@@ -1,7 +1,10 @@
 import { createRequestContext, runWithRequestContext } from "../shims/unified-request-context.js";
 import { patternToNextFormat } from "../routing/route-validation.js";
 import { getRequestExecutionContext } from "../shims/request-context.js";
+import { NEXTJS_DEPLOYMENT_ID_HEADER } from "./headers.js";
 import { reportRequestError } from "./instrumentation.js";
+import { NEVER_CACHE_CONTROL } from "./cache-control.js";
+import "./isr-decision.js";
 import { PRERENDER_REVALIDATE_HEADER, isOnDemandRevalidateRequest, isrCacheKey, isrGet, isrSet, triggerBackgroundRegeneration } from "./isr-cache.js";
 import { ensureFetchPatch } from "../shims/fetch-cache.js";
 import { mergeRouteParamsIntoQuery, parseQueryString } from "../utils/query.js";
@@ -140,8 +143,8 @@ function createPagesPageHandler(opts) {
 					});
 					if (methodResponse) return methodResponse;
 				}
-				const pageModuleUrl = resolveClientModuleUrl(manifest, route.filePath);
-				const appModuleUrl = resolveClientModuleUrl(manifest, appAssetPath);
+				const pageModuleUrl = resolveClientModuleUrl(manifest, route.filePath, vinextConfig.basePath, vinextConfig.assetPrefix);
+				const appModuleUrl = resolveClientModuleUrl(manifest, appAssetPath, vinextConfig.basePath, vinextConfig.assetPrefix);
 				const serializedPagesNextData = {
 					...pagesNextData,
 					__vinext: {
@@ -163,6 +166,7 @@ function createPagesPageHandler(opts) {
 					err,
 					applyRequestContexts: applySSRContext,
 					buildId,
+					deploymentId: process.env.__VINEXT_DEPLOYMENT_ID || process.env.NEXT_DEPLOYMENT_ID,
 					createGsspReqRes() {
 						return createPagesReqRes({
 							body: void 0,
@@ -203,7 +207,10 @@ function createPagesPageHandler(opts) {
 					statusCode: renderStatusCode,
 					triggerBackgroundRegeneration,
 					vinext: serializedPagesNextData.__vinext,
-					nextData: serializedPagesNextData
+					nextData: serializedPagesNextData,
+					userAgent: request.headers.get("user-agent") ?? void 0,
+					ifNoneMatch: request.headers.get("if-none-match") ?? void 0,
+					requestCacheControl: request.headers.get("cache-control") ?? void 0
 				});
 				if (pageDataResult.kind === "notFound") {
 					const notFoundRoute = findNotFoundRoute();
@@ -251,7 +258,11 @@ function createPagesPageHandler(opts) {
 							hasUserCacheControl = true;
 							break;
 						}
-						if (!hasUserCacheControl) init.headers["Cache-Control"] = "private, no-cache, no-store, max-age=0, must-revalidate";
+						if (!hasUserCacheControl) init.headers["Cache-Control"] = NEVER_CACHE_CONTROL;
+					}
+					if (routePattern !== "/_error" && routePattern !== "/500") {
+						const deploymentId = process.env.__VINEXT_DEPLOYMENT_ID || process.env.NEXT_DEPLOYMENT_ID;
+						if (deploymentId) init.headers[NEXTJS_DEPLOYMENT_ID_HEADER] = deploymentId;
 					}
 					return buildNextDataJsonResponse(pageProps, safeJsonStringify, init);
 				}
@@ -263,7 +274,9 @@ function createPagesPageHandler(opts) {
 						manifest,
 						moduleIds: pageModuleIds,
 						scriptNonce,
-						disableOptimizedLoading: vinextConfig.disableOptimizedLoading
+						disableOptimizedLoading: vinextConfig.disableOptimizedLoading,
+						basePath: vinextConfig.basePath,
+						assetPrefix: vinextConfig.assetPrefix
 					}),
 					buildId,
 					clearSsrContext() {
@@ -305,7 +318,10 @@ function createPagesPageHandler(opts) {
 					safeJsonStringify,
 					scriptNonce,
 					statusCode: renderStatusCode,
-					nextData: serializedPagesNextData
+					nextData: serializedPagesNextData,
+					userAgent: request.headers.get("user-agent") ?? void 0,
+					ifNoneMatch: request.headers.get("if-none-match") ?? void 0,
+					requestCacheControl: request.headers.get("cache-control") ?? void 0
 				});
 			} catch (e) {
 				console.error("[vinext] SSR error:", e);

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

@@ -4,6 +4,28 @@ import { RenderPageEnhancers } from "./pages-document-initial-props.js";
 import { ComponentType, ReactNode } from "react";
 
 //#region src/server/pages-page-response.d.ts
+/**
+ * Returns true when the User-Agent belongs to a bot or crawler that cannot
+ * reliably consume a streamed HTML response.
+ */
+declare function isPagesStreamingBot(userAgent: string): boolean;
+declare function generatePagesETag(payload: string): string;
+/**
+ * Mirrors Next.js `sendEtagResponse` semantics (weak/strong comparison).
+ *
+ * A weak ETag `W/"..."` matches both `W/"..."` and `"..."` in `If-None-Match`.
+ * A strong ETag `"..."` only matches the same strong token.
+ * `*` always matches.
+ */
+declare function etagMatches(etag: string, ifNoneMatch: string): boolean;
+/**
+ * Returns true when a request `Cache-Control` header asks to bypass the 304
+ * short-circuit. Mirrors the `fresh` package's check used by Next.js's
+ * `sendEtagResponse` (`/(?:^|,)\s*?no-cache\s*?(?:,|$)/`). Shared by the
+ * fresh-MISS bot path here and the ISR HIT/STALE paths in
+ * `pages-page-data.ts` so the two cannot drift.
+ */
+declare function requestsNoCache(cacheControl: string | undefined): boolean;
 type PagesFontPreload = {
   href: string;
   type: string;
@@ -82,10 +104,32 @@ type RenderPagesPageResponseOptions = {
   statusCode?: number;
   vinext?: VinextNextData["__vinext"];
   nextData?: PagesNextDataExtras;
+  /**
+   * The request's User-Agent string (from `request.headers.get('user-agent')`).
+   * When this matches a known crawler / bot pattern, the response is fully
+   * buffered before sending so bots receive a single complete HTML chunk with
+   * an ETag header. Omitting this field disables bot-detection (streaming as
+   * normal), which is the correct behaviour for non-HTML requests and tests.
+   */
+  userAgent?: string;
+  /**
+   * The incoming request's `If-None-Match` header value. When set and the
+   * computed ETag matches (weak-ETag semantics, mirroring Next.js's
+   * `sendEtagResponse`), a `304 Not Modified` is returned with an empty body.
+   * Only evaluated on bot/buffered responses that carry an ETag.
+   */
+  ifNoneMatch?: string;
+  /**
+   * The incoming request's `Cache-Control` header value. When the value
+   * contains `no-cache`, the 304 short-circuit is skipped and a full 200
+   * response is always returned — mirroring the `fresh` package used by
+   * Next.js's `sendEtagResponse`.
+   */
+  requestCacheControl?: string;
 };
 declare function buildPagesNextDataScript(options: Pick<RenderPagesPageResponseOptions, "buildId" | "i18n" | "isFallback" | "pageProps" | "params" | "routePattern" | "safeJsonStringify" | "scriptNonce" | "nextData"> & {
   vinext?: VinextNextData["__vinext"];
 }): string;
 declare function renderPagesPageResponse(options: RenderPagesPageResponseOptions): Promise<Response>;
 //#endregion
-export { PagesGsspResponse, PagesI18nRenderContext, PagesNextDataExtras, buildPagesNextDataScript, renderPagesPageResponse };
+export { PagesGsspResponse, PagesI18nRenderContext, PagesNextDataExtras, buildPagesNextDataScript, etagMatches, generatePagesETag, isPagesStreamingBot, renderPagesPageResponse, requestsNoCache };

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

@@ -1,16 +1,64 @@
 import { getRequestExecutionContext } from "../shims/request-context.js";
 import { reportRequestError } from "./instrumentation.js";
 import { setCacheStateHeaders } from "./cache-headers.js";
+import { fnv1a52 } from "../utils/hash.js";
 import { encodeCacheTag } from "../utils/encode-cache-tag.js";
+import { NEVER_CACHE_CONTROL, NO_STORE_CACHE_CONTROL, applyCdnResponseHeaders } from "./cache-control.js";
+import { buildMissIsrCacheControl } from "./isr-decision.js";
 import { withScriptNonce } from "../shims/script-nonce-context.js";
 import { createInlineScriptTag, createNonceAttribute, escapeHtmlAttr } from "./html.js";
 import { getClientTraceMetadataHTML } from "./client-trace-metadata.js";
 import { readStreamAsText } from "../utils/text-stream.js";
 import { loadUserDocumentInitialProps, runDocumentRenderPage } from "./pages-document-initial-props.js";
 import { callDocumentGetInitialProps } from "./document-initial-head.js";
-import { applyCdnResponseHeaders, buildRevalidateCacheControl } from "./cache-control.js";
 import React from "react";
 //#region src/server/pages-page-response.ts
+/**
+* Crawlers that cannot handle streamed HTML: they read metadata only from
+* the first network chunk, so streaming would give them an incomplete <head>.
+* Pattern sourced from Next.js html-bots.ts (updated to match the canary).
+*/
+const HTML_LIMITED_BOT_UA_RE = /[\w-]+-Google|Google-[\w-]+|Chrome-Lighthouse|Slurp|DuckDuckBot|baiduspider|yandex|sogou|bitlybot|tumblr|vkShare|quora link preview|redditbot|ia_archiver|Bingbot|BingPreview|applebot|facebookexternalhit|facebookcatalog|Twitterbot|LinkedInBot|Slackbot|Discordbot|WhatsApp|SkypeUriPreview|Yeti|googleweblight/i;
+/**
+* Googlebot (the main search crawler) executes JavaScript via a headless
+* browser, so it too cannot safely handle mid-stream HTML mutations.
+* Matches "Googlebot" but NOT suffixed variants like "Googlebot-Image".
+*/
+const HEADLESS_BROWSER_BOT_UA_RE = /Googlebot(?!-)|Googlebot$/i;
+/**
+* Returns true when the User-Agent belongs to a bot or crawler that cannot
+* reliably consume a streamed HTML response.
+*/
+function isPagesStreamingBot(userAgent) {
+	return HEADLESS_BROWSER_BOT_UA_RE.test(userAgent) || HTML_LIMITED_BOT_UA_RE.test(userAgent);
+}
+function generatePagesETag(payload) {
+	return "\"" + fnv1a52(payload).toString(36) + payload.length.toString(36) + "\"";
+}
+/**
+* Mirrors Next.js `sendEtagResponse` semantics (weak/strong comparison).
+*
+* A weak ETag `W/"..."` matches both `W/"..."` and `"..."` in `If-None-Match`.
+* A strong ETag `"..."` only matches the same strong token.
+* `*` always matches.
+*/
+function etagMatches(etag, ifNoneMatch) {
+	if (ifNoneMatch === "*") return true;
+	const normalize = (t) => t.replace(/^W\//, "");
+	const etagNorm = normalize(etag.trim());
+	for (const token of ifNoneMatch.split(",")) if (normalize(token.trim()) === etagNorm) return true;
+	return false;
+}
+/**
+* Returns true when a request `Cache-Control` header asks to bypass the 304
+* short-circuit. Mirrors the `fresh` package's check used by Next.js's
+* `sendEtagResponse` (`/(?:^|,)\s*?no-cache\s*?(?:,|$)/`). Shared by the
+* fresh-MISS bot path here and the ISR HIT/STALE paths in
+* `pages-page-data.ts` so the two cannot drift.
+*/
+function requestsNoCache(cacheControl) {
+	return /(?:^|,)\s*no-cache\s*(?:,|$)/.test(cacheControl ?? "");
+}
 function buildPagesFontHeadHtml(fontLinks, fontPreloads, fontStyles, scriptNonce) {
 	let html = "";
 	const nonceAttr = createNonceAttribute(scriptNonce);
@@ -201,21 +249,34 @@ async function renderPagesPageResponse(options) {
 	}
 	const compositeStream = await buildPagesCompositeStream(responseBodyStream, shellPrefix, shellSuffix);
 	const userSetCacheControl = responseHeaders.has("Cache-Control");
-	if (options.scriptNonce) responseHeaders.set("Cache-Control", "no-store, must-revalidate");
+	if (options.scriptNonce) responseHeaders.set("Cache-Control", NO_STORE_CACHE_CONTROL);
 	else if (options.isrRevalidateSeconds) {
 		const isrPathname = options.routeUrl.split("?")[0];
 		const stem = isrPathname.endsWith("/") ? isrPathname.slice(0, -1) : isrPathname;
 		applyCdnResponseHeaders(responseHeaders, {
-			cacheControl: buildRevalidateCacheControl(options.isrRevalidateSeconds, options.expireSeconds),
+			cacheControl: buildMissIsrCacheControl(options.isrRevalidateSeconds, options.expireSeconds),
 			tags: [encodeCacheTag(`_N_T_${stem || "/"}`)]
 		});
 		setCacheStateHeaders(responseHeaders, "MISS");
-	} else if (options.gsspRes && !userSetCacheControl) responseHeaders.set("Cache-Control", "private, no-cache, no-store, max-age=0, must-revalidate");
+	} else if (options.gsspRes && !userSetCacheControl) responseHeaders.set("Cache-Control", NEVER_CACHE_CONTROL);
 	if (options.fontLinkHeader) responseHeaders.set("Link", options.fontLinkHeader);
+	if (options.userAgent && isPagesStreamingBot(options.userAgent)) {
+		const fullHtml = await readStreamAsText(compositeStream);
+		const etag = generatePagesETag(fullHtml);
+		responseHeaders.set("ETag", etag);
+		if (!requestsNoCache(options.requestCacheControl) && options.ifNoneMatch && etagMatches(etag, options.ifNoneMatch)) return new Response(null, {
+			status: 304,
+			headers: responseHeaders
+		});
+		return new Response(fullHtml, {
+			status: finalStatus,
+			headers: responseHeaders
+		});
+	}
 	return Object.assign(new Response(compositeStream, {
 		status: finalStatus,
 		headers: responseHeaders
 	}), { __vinextStreamedHtmlResponse: true });
 }
 //#endregion
-export { buildPagesNextDataScript, renderPagesPageResponse };
+export { buildPagesNextDataScript, etagMatches, generatePagesETag, isPagesStreamingBot, renderPagesPageResponse, requestsNoCache };

package/dist/server/pages-readiness.d.ts

@@ -33,4 +33,4 @@ declare function buildPagesReadinessNextData(options: {
   hasRewrites: boolean;
 }): PagesReadinessNextData;
 //#endregion
-export { PagesReadinessNextData, buildPagesReadinessNextData };
+export { buildPagesReadinessNextData };

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

@@ -62,6 +62,20 @@ type PagesPipelineDeps = {
    */
   serveStaticFile?: ((requestPathname: string, stagedHeaders: HeaderRecord) => Promise<boolean>) | null;
 };
+/**
+ * Wrap an adapter's `runMiddleware` callback so middleware receives the original
+ * (pre-basePath-stripping) URL. Adapters strip the basePath before handing the
+ * request to `runPagesRequest`, but Next.js passes the un-stripped URL to the
+ * middleware adapter so `request.nextUrl.basePath` reflects whether the URL
+ * actually had the basePath prefix. Requests outside the basePath
+ * (`hadBasePath === false`) are passed through untouched so middleware sees
+ * `nextUrl.basePath === ""` and can redirect them into the basePath
+ * (see the middleware-base-path e2e test / #1830).
+ *
+ * Shared by the Node prod server (prod-server.ts) and the generated Pages
+ * Router worker entry (deploy.ts) to keep the two adapters in sync.
+ */
+declare function wrapMiddlewareWithBasePath(runMiddleware: NonNullable<PagesPipelineDeps["runMiddleware"]>, basePath: string, hadBasePath: boolean): NonNullable<PagesPipelineDeps["runMiddleware"]>;
 type PagesPipelineResult = {
   type: "response";
   response: Response;
@@ -96,4 +110,4 @@ type PagesPipelineResult = {
  */
 declare function runPagesRequest(request: Request, deps: PagesPipelineDeps): Promise<PagesPipelineResult>;
 //#endregion
-export { MiddlewareResult, PagesPipelineDeps, PagesPipelineResult, PagesRenderOptions, runPagesRequest };
+export { MiddlewareResult, PagesPipelineDeps, PagesPipelineResult, PagesRenderOptions, runPagesRequest, wrapMiddlewareWithBasePath };

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

@@ -1,4 +1,4 @@
-import { hasBasePath } from "../utils/base-path.js";
+import { addBasePathToPathname, hasBasePath } from "../utils/base-path.js";
 import { applyMiddlewareRequestHeaders, isExternalUrl, matchRedirect, matchRewrite, preserveRedirectDestinationQuery, proxyExternalRequest, requestContextFromRequest, sanitizeDestination } from "../config/config-matchers.js";
 import { applyConfigHeadersToHeaderRecord, normalizeTrailingSlash } from "./request-pipeline.js";
 import { mergeRewriteQuery } from "../utils/query.js";
@@ -6,6 +6,27 @@ import { normalizeDefaultLocalePathname, stripI18nLocaleForApiRoute } from "./pa
 import { mergeHeaders } from "./worker-utils.js";
 //#region src/server/pages-request-pipeline.ts
 /**
+* Wrap an adapter's `runMiddleware` callback so middleware receives the original
+* (pre-basePath-stripping) URL. Adapters strip the basePath before handing the
+* request to `runPagesRequest`, but Next.js passes the un-stripped URL to the
+* middleware adapter so `request.nextUrl.basePath` reflects whether the URL
+* actually had the basePath prefix. Requests outside the basePath
+* (`hadBasePath === false`) are passed through untouched so middleware sees
+* `nextUrl.basePath === ""` and can redirect them into the basePath
+* (see the middleware-base-path e2e test / #1830).
+*
+* Shared by the Node prod server (prod-server.ts) and the generated Pages
+* Router worker entry (deploy.ts) to keep the two adapters in sync.
+*/
+function wrapMiddlewareWithBasePath(runMiddleware, basePath, hadBasePath) {
+	if (!hadBasePath || !basePath) return runMiddleware;
+	return (request, ctx, opts) => {
+		const mwUrl = new URL(request.url);
+		mwUrl.pathname = addBasePathToPathname(mwUrl.pathname, basePath);
+		return runMiddleware(new Request(mwUrl, request), ctx, opts);
+	};
+}
+/**
 * Run the Pages Router request pipeline.
 *
 * ASSUMPTION: request already has internal headers filtered and basePath stripped.
@@ -206,4 +227,4 @@ async function runPagesRequest(request, deps) {
 	};
 }
 //#endregion
-export { runPagesRequest };
+export { runPagesRequest, wrapMiddlewareWithBasePath };

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

@@ -3,6 +3,44 @@ import { resolveRequestHost, trustProxy, trustedHosts } from "./proxy-trust.js";
 import { IncomingMessage, ServerResponse } from "node:http";
 
 //#region src/server/prod-server.d.ts
+/**
+ * Import a built server entry module (App Router RSC entry or Pages Router
+ * server entry) by absolute file path.
+ *
+ * The first import of a given path uses the plain file:// URL with NO query
+ * string. This is load-bearing: code-split builds emit lazy chunks that
+ * import the entry back by bare specifier (default Vite builds on both
+ * supported majors — Rollup on Vite 7 and Rolldown on Vite 8 — hoist modules
+ * shared between the entry's static graph and lazy route chunks into the
+ * entry chunk, which the chunks then import as e.g. "../../index.js").
+ * Node keys its ESM cache on the full URL including the query string, so if
+ * the server imported the entry as `index.js?t=<mtime>`, a chunk's bare
+ * back-import would evaluate the entire server bundle a second time and
+ * module-level singletons (db pools, service registries) would silently
+ * diverge between the two copies. See
+ * https://github.com/cloudflare/vinext/issues/1923.
+ *
+ * A `?t=<mtime>` query string is appended only when the same path is
+ * imported again after a rebuild (different mtime) — e.g. test suites that
+ * rebuild a fixture to the same output path within one process — where the
+ * bare URL's cache entry would return the stale previous build. Note this
+ * rebuild branch trades the single-instance guarantee back: chunks that
+ * import the entry by bare path still resolve to the FIRST build's cache
+ * entry, so freshness and single-instance only hold together on the first
+ * import of a path. Production processes import each entry path exactly
+ * once and always get both.
+ *
+ * The entry is imported via its canonical real path: the bundler
+ * canonicalizes module ids with fs.realpathSync.native, so chunks evaluate
+ * under realpath-based URLs and their relative imports resolve to realpath
+ * URLs too. Importing the entry through a symlinked path (macOS /var/...
+ * tmpdirs, symlinked deploy directories) would otherwise create a second
+ * instance keyed on the symlinked URL.
+ *
+ * Exported for direct unit testing of the URL choice.
+ */
+declare function resolveServerEntryImportUrl(entryPath: string): string;
+declare function importServerEntryModule(entryPath: string): Promise<any>;
 type ProdServerOptions = {
   /** Port to listen on */port?: number; /** Host to bind to */
   host?: string; /** Path to the build output directory */
@@ -105,4 +143,4 @@ declare function resolveAppRouterPrerenderSeeder(entryModule: unknown): AppRoute
  */
 declare function resolveAppRouterAssetPath(pathname: string, assetPathPrefix: string, assetPrefix: string): string | null;
 //#endregion
-export { COMPRESSIBLE_TYPES, COMPRESS_THRESHOLD, ProdServerOptions, mergeResponseHeaders, mergeWebResponse, negotiateEncoding, nodeToWebRequest, resolveAppRouterAssetPath, resolveAppRouterPrerenderSeeder, resolveRequestHost as resolveHost, sendCompressed, sendWebResponse, startProdServer, trustProxy, trustedHosts, tryServeStatic };
+export { COMPRESSIBLE_TYPES, COMPRESS_THRESHOLD, ProdServerOptions, importServerEntryModule, mergeResponseHeaders, mergeWebResponse, negotiateEncoding, nodeToWebRequest, resolveAppRouterAssetPath, resolveAppRouterPrerenderSeeder, resolveRequestHost as resolveHost, resolveServerEntryImportUrl, sendCompressed, sendWebResponse, startProdServer, trustProxy, trustedHosts, tryServeStatic };

package/dist/server/prod-server.js

@@ -8,17 +8,14 @@ import { isUnknownRecord } from "../utils/record.js";
 import { resolveRequestHost, resolveRequestProtocol, trustProxy, trustedHosts } from "./proxy-trust.js";
 import { DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES, isImageOptimizationPath, isSafeImageContentType, parseImageParams } from "./image-optimization.js";
 import { installSocketErrorBackstop } from "./socket-error-backstop.js";
-import { ASSET_PREFIX_URL_DIR, assetPrefixPathname, isAbsoluteAssetPrefix, resolveAssetsDir } from "../utils/asset-prefix.js";
+import { ASSET_PREFIX_URL_DIR, assetPrefixPathname, isAbsoluteAssetPrefix } from "../utils/asset-prefix.js";
 import { CONTENT_TYPES, StaticFileCache, etagFromFilenameHash } from "./static-file-cache.js";
 import { buildNextDataNotFoundResponse, isNextDataPathname, parseNextDataPathname } from "./pages-data-route.js";
 import { collectInlineCssManifest } from "../build/inline-css.js";
 import { mergeHeaders } from "./worker-utils.js";
-import { runPagesRequest } from "./pages-request-pipeline.js";
-import { manifestFileWithBase } from "../utils/manifest-paths.js";
+import { runPagesRequest, wrapMiddlewareWithBasePath } from "./pages-request-pipeline.js";
 import { readTrustedPrerenderRouteParamsFromHeaders, serializePrerenderRouteParamsHeader } from "./prerender-route-params.js";
-import { computeLazyChunks } from "../utils/lazy-chunks.js";
-import { findClientEntryFile, findPagesClientEntryFile, readClientBuildManifest } from "../utils/client-build-manifest.js";
-import { findClientEntryFileFromVinextManifest, findPagesClientEntryFileFromVinextManifest, readClientEntryManifest } from "../utils/client-entry-manifest.js";
+import { computeClientRuntimeMetadata } from "../utils/client-runtime-metadata.js";
 import { readPrerenderSecret } from "../build/server-manifest.js";
 import { seedMemoryCacheFromPrerender } from "./seed-cache.js";
 import fs from "node:fs";
@@ -48,6 +45,68 @@ import { Readable, pipeline } from "node:stream";
 * - dist/server/index.js — RSC entry (default export: handler(Request) → Response)
 * - dist/server/ssr/index.js — SSR entry (imported by RSC entry at runtime)
 */
+/**
+* mtime of the build each bare (query-less) server-entry URL was first
+* imported from in this process. Node's ESM cache pins a bare URL to that
+* build forever, so rebuilds to the same path must be detected and loaded
+* through a cache-busted URL instead.
+*/
+const bareServerEntryMtimes = /* @__PURE__ */ new Map();
+/**
+* Import a built server entry module (App Router RSC entry or Pages Router
+* server entry) by absolute file path.
+*
+* The first import of a given path uses the plain file:// URL with NO query
+* string. This is load-bearing: code-split builds emit lazy chunks that
+* import the entry back by bare specifier (default Vite builds on both
+* supported majors — Rollup on Vite 7 and Rolldown on Vite 8 — hoist modules
+* shared between the entry's static graph and lazy route chunks into the
+* entry chunk, which the chunks then import as e.g. "../../index.js").
+* Node keys its ESM cache on the full URL including the query string, so if
+* the server imported the entry as `index.js?t=<mtime>`, a chunk's bare
+* back-import would evaluate the entire server bundle a second time and
+* module-level singletons (db pools, service registries) would silently
+* diverge between the two copies. See
+* https://github.com/cloudflare/vinext/issues/1923.
+*
+* A `?t=<mtime>` query string is appended only when the same path is
+* imported again after a rebuild (different mtime) — e.g. test suites that
+* rebuild a fixture to the same output path within one process — where the
+* bare URL's cache entry would return the stale previous build. Note this
+* rebuild branch trades the single-instance guarantee back: chunks that
+* import the entry by bare path still resolve to the FIRST build's cache
+* entry, so freshness and single-instance only hold together on the first
+* import of a path. Production processes import each entry path exactly
+* once and always get both.
+*
+* The entry is imported via its canonical real path: the bundler
+* canonicalizes module ids with fs.realpathSync.native, so chunks evaluate
+* under realpath-based URLs and their relative imports resolve to realpath
+* URLs too. Importing the entry through a symlinked path (macOS /var/...
+* tmpdirs, symlinked deploy directories) would otherwise create a second
+* instance keyed on the symlinked URL.
+*
+* Exported for direct unit testing of the URL choice.
+*/
+function resolveServerEntryImportUrl(entryPath) {
+	let canonicalEntryPath;
+	try {
+		canonicalEntryPath = fs.realpathSync.native(entryPath);
+	} catch {
+		canonicalEntryPath = entryPath;
+	}
+	const href = pathToFileURL(canonicalEntryPath).href;
+	const mtime = fs.statSync(canonicalEntryPath).mtimeMs;
+	const bareMtime = bareServerEntryMtimes.get(href);
+	if (bareMtime === void 0 || bareMtime === mtime) {
+		bareServerEntryMtimes.set(href, mtime);
+		return href;
+	}
+	return `${href}?t=${mtime}`;
+}
+async function importServerEntryModule(entryPath) {
+	return import(resolveServerEntryImportUrl(entryPath));
+}
 /** Convert a Node.js IncomingMessage into a ReadableStream for Web Request body. */
 function readNodeStream(req) {
 	return new ReadableStream({ start(controller) {
@@ -158,8 +217,14 @@ const NO_BODY_RESPONSE_STATUSES = new Set([
 	205,
 	304
 ]);
-function omitHeadersCaseInsensitive(headersRecord, names) {
-	const targets = new Set(names.map((name) => name.toLowerCase()));
+const OMIT_BODY_HEADERS = new Set(["content-length", "content-type"]);
+const OMIT_STATIC_RESPONSE_HEADERS = new Set([
+	VINEXT_STATIC_FILE_HEADER,
+	"content-encoding",
+	"content-length",
+	"content-type"
+]);
+function omitHeadersCaseInsensitive(headersRecord, targets) {
 	const filtered = {};
 	for (const [key, value] of Object.entries(headersRecord)) {
 		if (targets.has(key.toLowerCase())) continue;
@@ -172,6 +237,15 @@ function matchesIfNoneMatchHeader(ifNoneMatch, etag) {
 	if (ifNoneMatch === "*") return true;
 	return ifNoneMatch.split(",").map((value) => value.trim()).some((value) => value === etag);
 }
+function installClientBuildManifestGlobals(clientDir, assetBase, assetPrefix) {
+	const metadata = computeClientRuntimeMetadata({
+		clientDir,
+		assetBase,
+		assetPrefix
+	});
+	globalThis.__VINEXT_LAZY_CHUNKS__ = metadata.lazyChunks;
+	globalThis.__VINEXT_DYNAMIC_PRELOADS__ = metadata.dynamicPreloads;
+}
 function isNoBodyResponseStatus(status) {
 	return NO_BODY_RESPONSE_STATUSES.has(status);
 }
@@ -212,7 +286,7 @@ function sendCompressed(req, res, body, contentType, statusCode, extraHeaders =
 	const buf = typeof body === "string" ? Buffer.from(body) : body;
 	const baseType = contentType.split(";")[0].trim();
 	const encoding = compress ? negotiateEncoding(req) : null;
-	const headersWithoutBodyHeaders = omitHeadersCaseInsensitive(extraHeaders, ["content-length", "content-type"]);
+	const headersWithoutBodyHeaders = omitHeadersCaseInsensitive(extraHeaders, OMIT_BODY_HEADERS);
 	const writeHead = (headers) => {
 		if (statusText) res.writeHead(statusCode, statusText, headers);
 		else res.writeHead(statusCode, headers);
@@ -619,19 +693,15 @@ function readSsrManifest(clientDir) {
 function installPagesClientAssetGlobals(options) {
 	const ssrManifest = readSsrManifest(options.clientDir);
 	globalThis.__VINEXT_SSR_MANIFEST__ = Object.keys(ssrManifest).length > 0 ? ssrManifest : void 0;
-	const buildManifest = readClientBuildManifest(path.join(options.clientDir, ".vite", "manifest.json"));
-	const clientEntryManifest = readClientEntryManifest(options.clientDir);
-	const entryOptions = {
+	const metadata = computeClientRuntimeMetadata({
 		clientDir: options.clientDir,
-		assetsSubdir: options.assetsSubdir,
 		assetBase: options.assetBase,
-		...buildManifest ? { buildManifest } : {}
-	};
-	globalThis.__VINEXT_CLIENT_ENTRY__ = options.clientEntryLookup === "pages-client-entry" ? findPagesClientEntryFileFromVinextManifest(clientEntryManifest, options.assetBase) ?? findPagesClientEntryFile(entryOptions) : findClientEntryFileFromVinextManifest(clientEntryManifest, options.assetBase) ?? findClientEntryFile(entryOptions);
-	if (buildManifest) {
-		const lazyChunks = computeLazyChunks(buildManifest).map((file) => manifestFileWithBase(file, options.assetBase));
-		globalThis.__VINEXT_LAZY_CHUNKS__ = lazyChunks.length > 0 ? lazyChunks : void 0;
-	} else globalThis.__VINEXT_LAZY_CHUNKS__ = void 0;
+		assetPrefix: options.assetPrefix,
+		includeClientEntry: options.clientEntryLookup === "pages-client-entry" ? "pages-client-entry" : true
+	});
+	globalThis.__VINEXT_CLIENT_ENTRY__ = metadata.clientEntryFile;
+	globalThis.__VINEXT_LAZY_CHUNKS__ = metadata.lazyChunks;
+	globalThis.__VINEXT_DYNAMIC_PRELOADS__ = metadata.dynamicPreloads;
 	return ssrManifest;
 }
 /**
@@ -659,8 +729,7 @@ async function startAppRouterServer(options) {
 		imageConfig = JSON.parse(fs.readFileSync(imageConfigPath, "utf-8"));
 	} catch {}
 	const prerenderSecret = readPrerenderSecret(path.dirname(rscEntryPath));
-	const rscMtime = fs.statSync(rscEntryPath).mtimeMs;
-	const rscModule = await import(`${pathToFileURL(rscEntryPath).href}?t=${rscMtime}`);
+	const rscModule = await importServerEntryModule(rscEntryPath);
 	const rscHandler = resolveAppRouterHandler(rscModule.default);
 	const appRouterAssetPrefix = typeof rscModule.__assetPrefix === "string" ? rscModule.__assetPrefix : "";
 	const appRouterBasePath = typeof rscModule.__basePath === "string" ? rscModule.__basePath : "";
@@ -671,10 +740,11 @@ async function startAppRouterServer(options) {
 	const appAssetBase = appRouterBasePath ? `${appRouterBasePath}/` : "/";
 	if (appRouterHasPagesDir) installPagesClientAssetGlobals({
 		clientDir,
-		assetsSubdir: resolveAssetsDir(appRouterAssetPrefix),
+		assetPrefix: appRouterAssetPrefix,
 		assetBase: appAssetBase,
 		clientEntryLookup: "pages-client-entry"
 	});
+	else installClientBuildManifestGlobals(clientDir, appAssetBase, appRouterAssetPrefix);
 	const seededRoutes = await resolveAppRouterPrerenderSeeder(rscModule)(path.dirname(rscEntryPath));
 	if (seededRoutes > 0) console.log(`[vinext] Seeded ${seededRoutes} pre-rendered route${seededRoutes !== 1 ? "s" : ""} into memory cache`);
 	const staticCache = await StaticFileCache.create(clientDir);
@@ -745,12 +815,7 @@ async function startAppRouterServer(options) {
 				} catch {
 					staticFilePath = staticFileSignal;
 				}
-				const staticResponseHeaders = omitHeadersCaseInsensitive(mergeResponseHeaders({}, response), [
-					VINEXT_STATIC_FILE_HEADER,
-					"content-encoding",
-					"content-length",
-					"content-type"
-				]);
+				const staticResponseHeaders = omitHeadersCaseInsensitive(mergeResponseHeaders({}, response), OMIT_STATIC_RESPONSE_HEADERS);
 				const served = await tryServeStatic(req, res, clientDir, staticFilePath, compress, staticCache, staticResponseHeaders, response.status);
 				cancelResponseBody(response);
 				if (served) return;
@@ -804,8 +869,7 @@ function readPagesServerEntryPageRoutes(value) {
 */
 async function startPagesRouterServer(options) {
 	const { port, host, clientDir, serverEntryPath, compress, purpose } = options;
-	const serverMtime = fs.statSync(serverEntryPath).mtimeMs;
-	const serverEntry = await import(`${pathToFileURL(serverEntryPath).href}?t=${serverMtime}`);
+	const serverEntry = await importServerEntryModule(serverEntryPath);
 	const { renderPage, handleApiRoute: handleApi, runMiddleware, vinextConfig, buildId: pagesBuildId } = serverEntry;
 	const matchPageRoute = typeof serverEntry.matchPageRoute === "function" ? serverEntry.matchPageRoute : void 0;
 	const pageRoutes = readPagesServerEntryPageRoutes(serverEntry.pageRoutes);
@@ -832,7 +896,7 @@ async function startPagesRouterServer(options) {
 	} : void 0;
 	const ssrManifest = installPagesClientAssetGlobals({
 		clientDir,
-		assetsSubdir: resolveAssetsDir(assetPrefix),
+		assetPrefix,
 		assetBase,
 		clientEntryLookup: "any-client-entry"
 	});
@@ -963,7 +1027,7 @@ async function startPagesRouterServer(options) {
 				ctx: void 0,
 				rawSearch: rawQs,
 				matchPageRoute: matchPageRoute ?? null,
-				runMiddleware: typeof runMiddleware === "function" ? runMiddleware : null,
+				runMiddleware: typeof runMiddleware === "function" ? wrapMiddlewareWithBasePath(runMiddleware, basePath, hadBasePath) : null,
 				renderPage: typeof renderPage === "function" ? (request, resolvedUrl, options, stagedHeaders) => renderPage(request, resolvedUrl, ssrManifest, void 0, stagedHeaders, options) : null,
 				handleApi: typeof handleApi === "function" ? (request, apiUrl) => handleApi(request, apiUrl, createNodeExecutionContext()) : null,
 				serveStaticFile: async (requestPathname, stagedHeaders) => {
@@ -1018,4 +1082,4 @@ async function startPagesRouterServer(options) {
 	};
 }
 //#endregion
-export { COMPRESSIBLE_TYPES, COMPRESS_THRESHOLD, mergeResponseHeaders, mergeWebResponse, negotiateEncoding, nodeToWebRequest, resolveAppRouterAssetPath, resolveAppRouterPrerenderSeeder, resolveRequestHost as resolveHost, sendCompressed, sendWebResponse, startProdServer, trustProxy, trustedHosts, tryServeStatic };
+export { COMPRESSIBLE_TYPES, COMPRESS_THRESHOLD, importServerEntryModule, mergeResponseHeaders, mergeWebResponse, negotiateEncoding, nodeToWebRequest, resolveAppRouterAssetPath, resolveAppRouterPrerenderSeeder, resolveRequestHost as resolveHost, resolveServerEntryImportUrl, sendCompressed, sendWebResponse, startProdServer, trustProxy, trustedHosts, tryServeStatic };

package/dist/shims/cache-runtime.js

@@ -3,7 +3,7 @@ import { getRequestContext, isInsideUnifiedScope, runWithUnifiedStateMutation }
 import { VINEXT_RSC_MARKER_HEADER } from "../server/headers.js";
 import { markDynamicUsage } from "./headers.js";
 import { _registerCacheContextAccessor, _setRequestScopedCacheLife, cacheLifeProfiles, getDataCacheHandler } from "./cache.js";
-import { addCollectedRequestTags } from "./fetch-cache.js";
+import { addCollectedRequestTags, getCurrentFetchSoftTags } from "./fetch-cache.js";
 //#region src/shims/cache-runtime.ts
 /**
 * "use cache" runtime
@@ -269,7 +269,11 @@ function registerCachedFunction(fn, id, variant, options = {}) {
 		}
 		if (isDev) return executeWithContext(fn, args, cacheVariant);
 		const handler = getDataCacheHandler();
-		const existing = await handler.get(cacheKey, { kind: "FETCH" });
+		const softTags = getCurrentFetchSoftTags();
+		const existing = await handler.get(cacheKey, {
+			kind: "FETCH",
+			softTags
+		});
 		if (existing?.value && existing.value.kind === "FETCH" && existing.cacheState !== "stale") try {
 			propagateCacheTagsToRequest(existing.value.tags);
 			if (rsc && existing.value.data.headers["x-vinext-rsc"] === "1") {
@@ -321,8 +325,11 @@ function registerCachedFunction(fn, id, variant, options = {}) {
 		value: fn.length,
 		configurable: true
 	});
+	cachedFn[USE_CACHE_FUNCTION_SYMBOL] = true;
 	return cachedFn;
 }
+/** @internal Symbol used to identify "use cache" wrapper functions. */
+const USE_CACHE_FUNCTION_SYMBOL = Symbol.for("vinext.useCacheFunction");
 function throwPrivateUseCacheInsidePublicUseCacheError() {
 	const error = /* @__PURE__ */ new Error("\"use cache: private\" must not be used within \"use cache\". It can only be nested inside of another \"use cache: private\".");
 	const ctx = getRequestContext();

package/dist/shims/dynamic-preload-chunks.d.ts

@@ -0,0 +1,8 @@
+import React from "react";
+
+//#region src/shims/dynamic-preload-chunks.d.ts
+declare function DynamicPreloadChunks(props: {
+  moduleIds?: readonly string[];
+}): React.FunctionComponentElement<React.FragmentProps> | null;
+//#endregion
+export { DynamicPreloadChunks };