vinext 0.0.27 → 0.0.29

package/dist/index.js

@@ -10,6 +10,7 @@ import { createDirectRunner } from "./server/dev-module-runner.js";
 import { generateRscEntry } from "./entries/app-rsc-entry.js";
 import { generateSsrEntry } from "./entries/app-ssr-entry.js";
 import { generateBrowserEntry } from "./entries/app-browser-entry.js";
+import { normalizePathnameForRouteMatchStrict } from "./routing/utils.js";
 import { loadNextConfig, resolveNextConfig, } from "./config/next-config.js";
 import { findMiddlewareFile, runMiddleware } from "./server/middleware.js";
 import { logRequest, now } from "./server/request-log.js";
@@ -21,8 +22,10 @@ import { isExternalUrl, proxyExternalRequest, matchHeaders, matchRedirect, match
 import { scanMetadataFiles } from "./server/metadata-routes.js";
 import { buildRequestHeadersFromMiddlewareResponse } from "./server/middleware-request-headers.js";
 import { detectPackageManager } from "./utils/project.js";
+import { manifestFileWithBase, manifestFilesWithBase, normalizeManifestFile, } from "./utils/manifest-paths.js";
 import { hasBasePath } from "./utils/base-path.js";
 import { asyncHooksStubPlugin } from "./plugins/async-hooks-stub.js";
+import { clientReferenceDedupPlugin } from "./plugins/client-reference-dedup.js";
 import { hasWranglerConfig, formatMissingCloudflarePluginError } from "./deploy.js";
 import tsconfigPaths from "vite-tsconfig-paths";
 import react from "@vitejs/plugin-react";
@@ -225,6 +228,12 @@ const POSTCSS_CONFIG_FILES = [
     ".postcssrc.yaml",
     ".postcssrc.yml",
 ];
+/**
+ * Module-level cache for resolvePostcssStringPlugins — avoids re-scanning per Vite environment.
+ * Stores the Promise itself so concurrent calls (RSC/SSR/Client config() hooks firing in
+ * parallel) all await the same in-flight scan rather than each starting their own.
+ */
+const _postcssCache = new Map();
 /**
  * Resolve PostCSS string plugin names in a project's PostCSS config.
  *
@@ -237,7 +246,14 @@ const POSTCSS_CONFIG_FILES = [
  * Returns the resolved PostCSS config object to inject into Vite's
  * `css.postcss`, or `undefined` if no resolution is needed.
  */
-async function resolvePostcssStringPlugins(projectRoot) {
+function resolvePostcssStringPlugins(projectRoot) {
+    if (_postcssCache.has(projectRoot))
+        return _postcssCache.get(projectRoot);
+    const promise = _resolvePostcssStringPluginsUncached(projectRoot);
+    _postcssCache.set(projectRoot, promise);
+    return promise;
+}
+async function _resolvePostcssStringPluginsUncached(projectRoot) {
     // Find the PostCSS config file
     let configPath = null;
     for (const name of POSTCSS_CONFIG_FILES) {
@@ -247,8 +263,9 @@ async function resolvePostcssStringPlugins(projectRoot) {
             break;
         }
     }
-    if (!configPath)
+    if (!configPath) {
         return undefined;
+    }
     // Load the config file
     let config;
     try {
@@ -275,11 +292,13 @@ async function resolvePostcssStringPlugins(projectRoot) {
     }
     // Only process array-form plugins that contain string entries
     // (either bare strings or tuple form ["plugin-name", { options }])
-    if (!config || !Array.isArray(config.plugins))
+    if (!config || !Array.isArray(config.plugins)) {
         return undefined;
+    }
     const hasStringPlugins = config.plugins.some((p) => typeof p === "string" || (Array.isArray(p) && typeof p[0] === "string"));
-    if (!hasStringPlugins)
+    if (!hasStringPlugins) {
         return undefined;
+    }
     // Resolve string plugin names to actual plugin functions
     const req = createRequire(path.join(projectRoot, "package.json"));
     const resolved = await Promise.all(config.plugins.filter(Boolean).map(async (plugin) => {
@@ -502,7 +521,59 @@ function computeLazyChunks(buildManifest) {
     }
     return lazyChunks;
 }
+function normalizeManifestModuleId(moduleId, root) {
+    const normalizedId = moduleId.replace(/\\/g, "/");
+    const isWindowsAbsolute = /^[a-zA-Z]:[\\/]/.test(moduleId) || moduleId.startsWith("\\\\");
+    if (isWindowsAbsolute) {
+        const relativeId = path.win32.relative(root, moduleId).replace(/\\/g, "/");
+        if (!relativeId || relativeId.startsWith("../"))
+            return normalizedId;
+        return relativeId;
+    }
+    if (!path.isAbsolute(moduleId))
+        return normalizedId;
+    const relativeId = path.relative(root, moduleId).replace(/\\/g, "/");
+    if (!relativeId || relativeId.startsWith("../"))
+        return normalizedId;
+    return relativeId;
+}
+function augmentSsrManifestFromBundle(ssrManifest, bundle, root, base = "/") {
+    const nextManifest = Object.fromEntries(Object.entries(ssrManifest).map(([key, files]) => [
+        key,
+        new Set(files.map((file) => normalizeManifestFile(file))),
+    ]));
+    for (const item of Object.values(bundle)) {
+        if (item.type !== "chunk")
+            continue;
+        const chunk = item;
+        const files = new Set();
+        files.add(manifestFileWithBase(chunk.fileName, base));
+        for (const importedFile of chunk.imports ?? []) {
+            files.add(manifestFileWithBase(importedFile, base));
+        }
+        for (const cssFile of chunk.viteMetadata?.importedCss ?? []) {
+            files.add(manifestFileWithBase(cssFile, base));
+        }
+        for (const assetFile of chunk.viteMetadata?.importedAssets ?? []) {
+            files.add(manifestFileWithBase(assetFile, base));
+        }
+        for (const moduleId of Object.keys(chunk.modules ?? {})) {
+            const key = normalizeManifestModuleId(moduleId, root);
+            if (key.startsWith("node_modules/") || key.includes("/node_modules/"))
+                continue;
+            if (key.startsWith("\0"))
+                continue;
+            if (!nextManifest[key])
+                nextManifest[key] = new Set();
+            for (const file of files) {
+                nextManifest[key].add(file);
+            }
+        }
+    }
+    return Object.fromEntries(Object.entries(nextManifest).map(([key, files]) => [key, [...files]]));
+}
 export default function vinext(options = {}) {
+    const viteMajorVersion = getViteMajorVersion();
     let root;
     let pagesDir;
     let appDir;
@@ -518,6 +589,11 @@ export default function vinext(options = {}) {
     const shimsDir = path.resolve(__dirname, "shims");
     // Shim alias map — populated in config(), used by resolveId() for .js variants
     let nextShimMap = {};
+    // Build-only cache for og-inline-fetch-assets to avoid repeated file reads
+    // during a single production build. Dev mode skips the cache so asset edits
+    // are picked up without restarting the Vite server.
+    const _ogInlineCache = new Map();
+    let _ogInlineIsBuild = false;
     /**
      * Generate the virtual SSR server entry module.
      * This is the entry point for `vite build --ssr`.
@@ -597,7 +673,8 @@ export default function vinext(options = {}) {
     const plugins = [
         // Resolve tsconfig paths/baseUrl aliases so real-world Next.js repos
         // that use @/*, #/*, or baseUrl imports work out of the box.
-        tsconfigPaths(),
+        // Vite 8+ supports this natively via resolve.tsconfigPaths.
+        ...(viteMajorVersion >= 8 ? [] : [tsconfigPaths()]),
         // React Fast Refresh + JSX transform for client components.
         reactPlugin,
         // Transform CJS require()/module.exports to ESM before other plugins
@@ -608,6 +685,8 @@ export default function vinext(options = {}) {
             enforce: "pre",
             async config(config, env) {
                 root = config.root ?? process.cwd();
+                const userResolve = config.resolve;
+                const shouldEnableNativeTsconfigPaths = viteMajorVersion >= 8 && userResolve?.tsconfigPaths === undefined;
                 // Load .env files into process.env before anything else.
                 // Next.js loads .env files before evaluating next.config.js, so
                 // env vars are available in config, server-side code, and as
@@ -711,34 +790,58 @@ export default function vinext(options = {}) {
                 defines["process.env.__VINEXT_DRAFT_SECRET"] = JSON.stringify(crypto.randomUUID());
                 // Build ID — resolved from next.config generateBuildId() or random UUID.
                 // Exposed so server entries and the next/server shim can inject it.
+                // Also used to namespace ISR cache keys so old cached entries from a
+                // previous deploy are never served by the new one.
                 defines["process.env.__VINEXT_BUILD_ID"] = JSON.stringify(nextConfig.buildId);
-                // Build the shim alias map — used by both resolve.alias and resolveId
-                // (resolveId handles .js extension variants for libraries like nuqs)
+                // Build the shim alias map. Exact `.js` variants are included for the
+                // public Next entrypoints that are file-backed in `next/package.json`.
+                // Some libraries (for example `nuqs`) import `next/navigation.js`
+                // directly; aliasing the `.js` form ensures optimizeDeps pre-bundles
+                // vinext's shim instead of real Next.
                 nextShimMap = {
                     ...nextConfig.aliases,
                     "next/link": path.join(shimsDir, "link"),
+                    "next/link.js": path.join(shimsDir, "link"),
                     "next/head": path.join(shimsDir, "head"),
+                    "next/head.js": path.join(shimsDir, "head"),
                     "next/router": path.join(shimsDir, "router"),
+                    "next/router.js": path.join(shimsDir, "router"),
                     "next/compat/router": path.join(shimsDir, "compat-router"),
+                    "next/compat/router.js": path.join(shimsDir, "compat-router"),
                     "next/image": path.join(shimsDir, "image"),
+                    "next/image.js": path.join(shimsDir, "image"),
                     "next/legacy/image": path.join(shimsDir, "legacy-image"),
+                    "next/legacy/image.js": path.join(shimsDir, "legacy-image"),
                     "next/dynamic": path.join(shimsDir, "dynamic"),
+                    "next/dynamic.js": path.join(shimsDir, "dynamic"),
                     "next/app": path.join(shimsDir, "app"),
+                    "next/app.js": path.join(shimsDir, "app"),
                     "next/document": path.join(shimsDir, "document"),
+                    "next/document.js": path.join(shimsDir, "document"),
                     "next/config": path.join(shimsDir, "config"),
                     "next/script": path.join(shimsDir, "script"),
+                    "next/script.js": path.join(shimsDir, "script"),
                     "next/server": path.join(shimsDir, "server"),
+                    "next/server.js": path.join(shimsDir, "server"),
                     "next/navigation": path.join(shimsDir, "navigation"),
+                    "next/navigation.js": path.join(shimsDir, "navigation"),
                     "next/headers": path.join(shimsDir, "headers"),
+                    "next/headers.js": path.join(shimsDir, "headers"),
                     "next/font/google": path.join(shimsDir, "font-google"),
                     "next/font/local": path.join(shimsDir, "font-local"),
                     "next/cache": path.join(shimsDir, "cache"),
+                    "next/cache.js": path.join(shimsDir, "cache"),
                     "next/form": path.join(shimsDir, "form"),
+                    "next/form.js": path.join(shimsDir, "form"),
                     "next/og": path.join(shimsDir, "og"),
+                    "next/og.js": path.join(shimsDir, "og"),
                     "next/web-vitals": path.join(shimsDir, "web-vitals"),
+                    "next/web-vitals.js": path.join(shimsDir, "web-vitals"),
                     "next/amp": path.join(shimsDir, "amp"),
                     "next/error": path.join(shimsDir, "error"),
+                    "next/error.js": path.join(shimsDir, "error"),
                     "next/constants": path.join(shimsDir, "constants"),
+                    "next/constants.js": path.join(shimsDir, "constants"),
                     // Internal next/dist/* paths used by popular libraries
                     // (next-intl, @clerk/nextjs, @sentry/nextjs, next-nprogress-bar, etc.)
                     "next/dist/shared/lib/app-router-context.shared-runtime": path.join(shimsDir, "internal", "app-router-context"),
@@ -931,6 +1034,7 @@ export default function vinext(options = {}) {
                         // causing cryptic "Invalid hook call" errors. This is a no-op
                         // when only one copy exists.
                         dedupe: ["react", "react-dom", "react/jsx-runtime", "react/jsx-dev-runtime"],
+                        ...(shouldEnableNativeTsconfigPaths ? { tsconfigPaths: true } : {}),
                     },
                     // Exclude vinext from dependency optimization so esbuild doesn't
                     // scan dist files containing virtual module imports (virtual:vinext-*)
@@ -943,7 +1047,7 @@ export default function vinext(options = {}) {
                     },
                     // Enable JSX in .tsx/.jsx files
                     // Vite 7 uses `esbuild` for transforms, Vite 8+ uses `oxc`
-                    ...(getViteMajorVersion() >= 8
+                    ...(viteMajorVersion >= 8
                         ? { oxc: { jsx: { runtime: "automatic" } } }
                         : { esbuild: { jsx: "automatic" } }),
                     // Define env vars for client bundle
@@ -1044,6 +1148,10 @@ export default function vinext(options = {}) {
                             consumer: "client",
                             optimizeDeps: {
                                 exclude: ["vinext"],
+                                // Crawl app/ source files up front so client-only deps imported
+                                // by user components are discovered during startup instead of
+                                // triggering a late re-optimisation + full page reload.
+                                entries: appEntries,
                                 // React packages aren't crawled from app/ source files,
                                 // so must be pre-included to avoid late discovery (#25).
                                 include: [
@@ -1138,18 +1246,6 @@ export default function vinext(options = {}) {
                     // ID (with \0 prefix). We need to re-resolve it so the client
                     // environment's import-analysis can find it.
                     const cleanId = id.startsWith("\0") ? id.slice(1) : id;
-                    // Handle next/* imports with .js extension (e.g. "next/navigation.js")
-                    // Libraries like nuqs import "next/navigation.js" which doesn't match
-                    // our resolve.alias for "next/navigation". Strip the .js and resolve
-                    // through our shim map, appending .js to the resolved path.
-                    if (cleanId.startsWith("next/") && cleanId.endsWith(".js")) {
-                        const withoutExt = cleanId.slice(0, -3);
-                        if (nextShimMap[withoutExt]) {
-                            const shimPath = nextShimMap[withoutExt];
-                            // Alias values don't include .js — append it for resolveId
-                            return shimPath.endsWith(".js") ? shimPath : shimPath + ".js";
-                        }
-                    }
                     // Pages Router virtual modules
                     if (cleanId === VIRTUAL_SERVER_ENTRY)
                         return RESOLVED_SERVER_ENTRY;
@@ -1205,6 +1301,7 @@ export default function vinext(options = {}) {
                         allowedOrigins: nextConfig?.serverActionsAllowedOrigins,
                         allowedDevOrigins: nextConfig?.allowedDevOrigins,
                         bodySizeLimit: nextConfig?.serverActionsBodySizeLimit,
+                        i18n: nextConfig?.i18n,
                     }, instrumentationPath);
                 }
                 if (id === RESOLVED_APP_SSR_ENTRY && hasAppDir) {
@@ -1217,6 +1314,8 @@ export default function vinext(options = {}) {
         },
         // Stub node:async_hooks in client builds — see src/plugins/async-hooks-stub.ts
         asyncHooksStubPlugin,
+        // Dedup client references from RSC proxy modules — see src/plugins/client-reference-dedup.ts
+        clientReferenceDedupPlugin(),
         // Proxy plugin for @mdx-js/rollup. The real MDX plugin is created lazily
         // during vinext:config's config() (when MDX files are detected), but
         // plugins returned from config() hooks run too late in the pipeline —
@@ -1637,7 +1736,7 @@ export default function vinext(options = {}) {
                             // decodeURIComponent prevents /%61dmin bypassing /admin matchers.
                             // normalizePath collapses // and resolves . / .. segments.
                             try {
-                                pathname = normalizePath(decodeURIComponent(pathname));
+                                pathname = normalizePath(normalizePathnameForRouteMatchStrict(pathname));
                             }
                             catch {
                                 // Malformed percent-encoding (e.g. /%E0%A4%A) — return 400 instead of crashing.
@@ -1685,6 +1784,30 @@ export default function vinext(options = {}) {
                                     return;
                                 }
                             }
+                            // When @cloudflare/vite-plugin is present, delegate the entire
+                            // Pages Router request pipeline to the Worker/miniflare side.
+                            // That keeps middleware, headers, redirects, rewrites, API
+                            // routes, and rendering in one place instead of mutating the
+                            // host request and forwarding post-middleware state downstream.
+                            if (hasCloudflarePlugin)
+                                return next();
+                            // Snapshot of req.headers before middleware runs. Used for both
+                            // preMiddlewareReqCtx and the middleware Request itself. Intentionally
+                            // captured once here — applyRequestHeadersToNodeRequest() mutates
+                            // req.headers later, but by then this Headers object is no longer read.
+                            const nodeRequestHeaders = new Headers(Object.fromEntries(Object.entries(req.headers)
+                                .filter(([, v]) => v !== undefined)
+                                .map(([k, v]) => [k, Array.isArray(v) ? v.join(", ") : String(v)])));
+                            const requestOrigin = `http://${req.headers.host || "localhost"}`;
+                            const preMiddlewareReqUrl = new URL(url, requestOrigin);
+                            const preMiddlewareReqCtx = requestContextFromRequest(new Request(preMiddlewareReqUrl, { headers: nodeRequestHeaders }));
+                            // Config redirects run before middleware, but still match against
+                            // the original normalized pathname and request headers/cookies.
+                            if (nextConfig?.redirects.length) {
+                                const redirected = applyRedirects(pathname, res, nextConfig.redirects, preMiddlewareReqCtx, nextConfig.basePath ?? "");
+                                if (redirected)
+                                    return;
+                            }
                             const applyRequestHeadersToNodeRequest = (nextRequestHeaders) => {
                                 for (const key of Object.keys(req.headers)) {
                                     delete req.headers[key];
@@ -1708,11 +1831,9 @@ export default function vinext(options = {}) {
                                 const origin = `${mwProto}://${req.headers.host || "localhost"}`;
                                 const middlewareRequest = new Request(new URL(url, origin), {
                                     method: req.method,
-                                    headers: Object.fromEntries(Object.entries(req.headers)
-                                        .filter(([, v]) => v !== undefined)
-                                        .map(([k, v]) => [k, Array.isArray(v) ? v.join(", ") : String(v)])),
+                                    headers: nodeRequestHeaders,
                                 });
-                                const result = await runMiddleware(getPagesRunner(), middlewarePath, middlewareRequest);
+                                const result = await runMiddleware(getPagesRunner(), middlewarePath, middlewareRequest, nextConfig?.i18n);
                                 if (!result.continue) {
                                     if (result.redirectUrl) {
                                         const redirectHeaders = {
@@ -1741,7 +1862,7 @@ export default function vinext(options = {}) {
                                         for (const [key, value] of result.response.headers) {
                                             res.appendHeader(key, value);
                                         }
-                                        const body = await result.response.text();
+                                        const body = Buffer.from(await result.response.arrayBuffer());
                                         res.end(body);
                                         return;
                                     }
@@ -1787,46 +1908,19 @@ export default function vinext(options = {}) {
                                     req.__vinextRewriteStatus = result.rewriteStatus;
                                 }
                             }
-                            // ── Cloudflare Workers dev mode ────────────────────────────
-                            // When @cloudflare/vite-plugin is present, ALL rendering runs
-                            // inside the miniflare Worker subprocess — both App Router (via
-                            // virtual:vinext-rsc-entry) and Pages Router (via
-                            // virtual:vinext-server-entry → renderPage/handleApiRoute).
-                            //
-                            // The Worker entry already handles config redirects, rewrites,
-                            // headers, and all routing internally. Running them here too
-                            // would duplicate that logic and produce incorrect behaviour
-                            // (double redirects, headers set on the wrong object, etc.).
-                            //
-                            // Middleware.ts is the only thing that belongs in the host connect
-                            // handler — it has already run above. Any terminal middleware
-                            // result (redirect, block response) has already been sent.
-                            // Any rewrite has been written back to req.url above so the
-                            // Cloudflare plugin's handler sees the correct path.
-                            //
-                            // Call next() to hand off to the Cloudflare plugin's connect
-                            // handler, which dispatches the request to miniflare.
-                            if (hasCloudflarePlugin)
-                                return next();
                             // Build request context once for has/missing condition checks
-                            // across headers, redirects, and rewrites.
+                            // for config rules that execute after middleware (rewrites).
                             // Convert Node.js IncomingMessage headers to a Web Request for
                             // requestContextFromRequest(), which uses the standard Web API.
-                            const reqUrl = new URL(url, `http://${req.headers.host || "localhost"}`);
-                            const reqCtxHeaders = middlewareRequestHeaders ??
-                                new Headers(Object.fromEntries(Object.entries(req.headers)
-                                    .filter(([, v]) => v !== undefined)
-                                    .map(([k, v]) => [k, Array.isArray(v) ? v.join(", ") : String(v)])));
+                            const reqUrl = new URL(url, requestOrigin);
+                            const reqCtxHeaders = middlewareRequestHeaders ?? nodeRequestHeaders;
                             const reqCtx = requestContextFromRequest(new Request(reqUrl, { headers: reqCtxHeaders }));
                             // Apply custom headers from next.config.js
+                            // Header matching still uses the original normalized pathname and
+                            // pre-middleware request state; middleware response headers win
+                            // later because they are already on the outgoing response.
                             if (nextConfig?.headers.length) {
-                                applyHeaders(pathname, res, nextConfig.headers, reqCtx);
-                            }
-                            // Apply redirects from next.config.js
-                            if (nextConfig?.redirects.length) {
-                                const redirected = applyRedirects(pathname, res, nextConfig.redirects, reqCtx, nextConfig.basePath ?? "");
-                                if (redirected)
-                                    return;
+                                applyHeaders(pathname, res, nextConfig.headers, preMiddlewareReqCtx);
                             }
                             // Apply rewrites from next.config.js (beforeFiles)
                             let resolvedUrl = url;
@@ -2409,11 +2503,20 @@ export default function vinext(options = {}) {
         {
             name: "vinext:og-inline-fetch-assets",
             enforce: "pre",
-            transform(code, id) {
+            configResolved(config) {
+                _ogInlineIsBuild = config.command === "build";
+            },
+            buildStart() {
+                if (_ogInlineIsBuild) {
+                    _ogInlineCache.clear();
+                }
+            },
+            async transform(code, id) {
                 // Quick bail-out: only process modules that use new URL(..., import.meta.url)
                 if (!code.includes("import.meta.url")) {
                     return null;
                 }
+                const useCache = _ogInlineIsBuild;
                 const moduleDir = path.dirname(id);
                 let newCode = code;
                 let didReplace = false;
@@ -2425,13 +2528,19 @@ export default function vinext(options = {}) {
                         const fullMatch = match[0];
                         const relPath = match[2]; // e.g. "./noto-sans-v27-latin-regular.ttf"
                         const absPath = path.resolve(moduleDir, relPath);
-                        let fileBase64;
-                        try {
-                            fileBase64 = fs.readFileSync(absPath).toString("base64");
-                        }
-                        catch {
-                            // File not found on disk — skip (may be a runtime-only asset)
-                            continue;
+                        let fileBase64 = useCache ? _ogInlineCache.get(absPath) : undefined;
+                        if (fileBase64 === undefined) {
+                            try {
+                                const buf = await fs.promises.readFile(absPath);
+                                fileBase64 = buf.toString("base64");
+                                if (useCache) {
+                                    _ogInlineCache.set(absPath, fileBase64);
+                                }
+                            }
+                            catch {
+                                // File not found on disk — skip (may be a runtime-only asset)
+                                continue;
+                            }
                         }
                         // Replace fetch(...).then(...) with an inline IIFE that returns Promise<ArrayBuffer>.
                         const inlined = [
@@ -2456,13 +2565,19 @@ export default function vinext(options = {}) {
                         const fullMatch = match[0];
                         const relPath = match[2]; // e.g. "./noto-sans-v27-latin-regular.ttf"
                         const absPath = path.resolve(moduleDir, relPath);
-                        let fileBase64;
-                        try {
-                            fileBase64 = fs.readFileSync(absPath).toString("base64");
-                        }
-                        catch {
-                            // File not found on disk — skip
-                            continue;
+                        let fileBase64 = useCache ? _ogInlineCache.get(absPath) : undefined;
+                        if (fileBase64 === undefined) {
+                            try {
+                                const buf = await fs.promises.readFile(absPath);
+                                fileBase64 = buf.toString("base64");
+                                if (useCache) {
+                                    _ogInlineCache.set(absPath, fileBase64);
+                                }
+                            }
+                            catch {
+                                // File not found on disk — skip
+                                continue;
+                            }
                         }
                         // Replace readFileSync(...) with Buffer.from("<base64>", "base64").
                         // Buffer is always available in Node.js and in the vinext SSR/RSC environments.
@@ -2561,6 +2676,38 @@ export default function vinext(options = {}) {
                 },
             },
         },
+        // Vite can emit empty SSR manifest entries for modules that Rollup inlines
+        // into another chunk. Pages Router looks up assets by page module path at
+        // runtime, so rebuild those mappings from the emitted client bundle.
+        {
+            name: "vinext:ssr-manifest-backfill",
+            apply: "build",
+            enforce: "post",
+            writeBundle: {
+                sequential: true,
+                order: "post",
+                handler(options, bundle) {
+                    const outDir = options.dir;
+                    if (!outDir)
+                        return;
+                    const viteDir = path.join(outDir, ".vite");
+                    const ssrManifestPath = path.join(viteDir, "ssr-manifest.json");
+                    if (!fs.existsSync(ssrManifestPath))
+                        return;
+                    try {
+                        const ssrManifest = JSON.parse(fs.readFileSync(ssrManifestPath, "utf-8"));
+                        const buildRoot = this.environment?.config.root ?? process.cwd();
+                        const buildBase = this.environment?.config.base ?? "/";
+                        const augmentedManifest = augmentSsrManifestFromBundle(ssrManifest, bundle, buildRoot, buildBase);
+                        fs.writeFileSync(ssrManifestPath, JSON.stringify(augmentedManifest, null, 2));
+                    }
+                    catch (err) {
+                        // Leave Vite's manifest untouched if parsing fails.
+                        console.warn("[vinext] Failed to augment SSR manifest:", err);
+                    }
+                },
+            },
+        },
         // Cloudflare Workers production build integration:
         // After all environments are built, compute lazy chunks from the client
         // build manifest and inject globals into the worker entry.
@@ -2592,6 +2739,7 @@ export default function vinext(options = {}) {
                     if (!fs.existsSync(distDir))
                         return;
                     const clientDir = path.resolve(buildRoot, "dist", "client");
+                    const clientBase = envConfig.base ?? "/";
                     // Read build manifest and compute lazy chunks (only reachable via
                     // dynamic imports). This runs for BOTH App Router and Pages Router.
                     // clientEntryFile is only used by the Pages Router path below —
@@ -2604,11 +2752,11 @@ export default function vinext(options = {}) {
                             const buildManifest = JSON.parse(fs.readFileSync(buildManifestPath, "utf-8"));
                             for (const [, value] of Object.entries(buildManifest)) {
                                 if (value && value.isEntry && value.file) {
-                                    clientEntryFile = value.file;
+                                    clientEntryFile = manifestFileWithBase(value.file, clientBase);
                                     break;
                                 }
                             }
-                            const lazy = computeLazyChunks(buildManifest);
+                            const lazy = manifestFilesWithBase(computeLazyChunks(buildManifest), clientBase);
                             if (lazy.length > 0)
                                 lazyChunksData = lazy;
                         }
@@ -2675,7 +2823,7 @@ export default function vinext(options = {}) {
                                 const entry = files.find((f) => (f.includes("vinext-client-entry") || f.includes("vinext-app-browser-entry")) &&
                                     f.endsWith(".js"));
                                 if (entry)
-                                    clientEntryFile = "assets/" + entry;
+                                    clientEntryFile = manifestFileWithBase("assets/" + entry, clientBase);
                             }
                         }
                         // Prepend globals to worker entry
@@ -3018,15 +3166,23 @@ function findFileWithExts(dir, name, matcher) {
     }
     return null;
 }
+/** Module-level cache for hasMdxFiles — avoids re-scanning per Vite environment. */
+const _mdxScanCache = new Map();
 /**
  * Check if the project has .mdx files in app/ or pages/ directories.
  */
 function hasMdxFiles(root, appDir, pagesDir) {
+    const cacheKey = `${root}\0${appDir ?? ""}\0${pagesDir ?? ""}`;
+    if (_mdxScanCache.has(cacheKey))
+        return _mdxScanCache.get(cacheKey);
     const dirs = [appDir, pagesDir].filter(Boolean);
     for (const dir of dirs) {
-        if (fs.existsSync(dir) && scanDirForMdx(dir))
+        if (fs.existsSync(dir) && scanDirForMdx(dir)) {
+            _mdxScanCache.set(cacheKey, true);
             return true;
+        }
     }
+    _mdxScanCache.set(cacheKey, false);
     return false;
 }
 function scanDirForMdx(dir) {
@@ -3054,7 +3210,11 @@ function scanDirForMdx(dir) {
 export { staticExportPages, staticExportApp } from "./build/static-export.js";
 // Exported for CLI and testing
 export { clientManualChunks, clientOutputConfig, clientTreeshakeConfig, computeLazyChunks };
+export { augmentSsrManifestFromBundle as _augmentSsrManifestFromBundle };
 export { resolvePostcssStringPlugins as _resolvePostcssStringPlugins };
+export { _postcssCache };
+export { hasMdxFiles as _hasMdxFiles };
+export { _mdxScanCache };
 export { parseStaticObjectLiteral as _parseStaticObjectLiteral };
 export { stripServerExports as _stripServerExports };
 export { asyncHooksStubPlugin as _asyncHooksStubPlugin };