vinext 0.0.27 → 0.0.28

package/dist/index.js

@@ -21,8 +21,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";
@@ -502,6 +504,57 @@ 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 = {}) {
     let root;
     let pagesDir;
@@ -711,6 +764,8 @@ 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)
@@ -1205,6 +1260,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 +1273,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 —
@@ -1685,6 +1743,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 +1790,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 = {
@@ -1787,46 +1867,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;
@@ -2561,6 +2614,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 +2677,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 +2690,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 +2761,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
@@ -3054,6 +3140,7 @@ 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 { parseStaticObjectLiteral as _parseStaticObjectLiteral };
 export { stripServerExports as _stripServerExports };