vike 0.4.236-commit-08fbc10 → 0.4.236-commit-cd565e9

package/dist/cjs/client/shared/createGetGlobalContextClient.js

@@ -7,10 +7,10 @@ const createGlobalContextShared_js_1 = require("../../shared/createGlobalContext
 const getJsonSerializedInHtml_js_1 = require("./getJsonSerializedInHtml.js");
 const utils_js_1 = require("./utils.js");
 const globalObject = (0, utils_js_1.getGlobalObject)('createGetGlobalContextClient.ts', (() => {
-    const { promise: globalContextPromise, resolve: globalContextPromiseResolve } = (0, utils_js_1.genPromise)();
+    const { promise: globalContextInitialPromise, resolve: globalContextInitialPromiseResolve } = (0, utils_js_1.genPromise)();
     return {
-        globalContextPromise,
-        globalContextPromiseResolve,
+        globalContextInitialPromise,
+        globalContextInitialPromiseResolve,
     };
 })());
 function createGetGlobalContextClient(virtualFileExports, isClientRouting, addGlobalContext) {
@@ -21,18 +21,22 @@ function createGetGlobalContextClient(virtualFileExports, isClientRouting, addGl
     return getGlobalContext;
     async function getGlobalContext() {
         // Cache
-        if (globalObject.globalContext &&
+        if (globalObject.virtualFileExports &&
             // Don't break HMR
-            globalObject.globalContext._virtualFileExports !== virtualFileExports) {
-            return globalObject.globalContext;
+            globalObject.virtualFileExports === virtualFileExports) {
+            const globalContext = await globalObject.globalContextPromise;
+            return globalContext;
+        }
+        else {
+            globalObject.virtualFileExports = virtualFileExports;
         }
         // Create
-        const globalContext = await (0, createGlobalContextShared_js_1.createGlobalContextShared)(virtualFileExports, globalObject, undefined, async (globalContext) => {
+        const globalContextPromise = (0, createGlobalContextShared_js_1.createGlobalContextShared)(virtualFileExports, globalObject, undefined, async (globalContext) => {
             const globalContextAddendum = {
                 /**
                  * Whether the environment is client-side or server-side / pre-rendering.
                  *
-                 * We recommend using `import.meta.env.SSR` instead, see https://vike.dev/globalContext
+                 * We recommend using `({}).SSR` instead, see https://vike.dev/globalContext
                  */
                 isClientSide: true,
             };
@@ -40,18 +44,24 @@ function createGetGlobalContextClient(virtualFileExports, isClientRouting, addGl
             (0, utils_js_1.objectAssign)(globalContextAddendum, await addGlobalContext?.(globalContext));
             return globalContextAddendum;
         });
-        (0, utils_js_1.assert)(globalObject.globalContext);
-        globalObject.globalContextPromiseResolve(globalObject.globalContext);
+        globalObject.globalContextPromise = globalContextPromise;
+        const globalContext = await globalContextPromise;
+        (0, utils_js_1.assert)(globalObject.globalContext === globalContext);
+        globalObject.globalContextInitialPromiseResolve();
         // Return
         return globalContext;
     }
 }
 async function getGlobalContext() {
+    await globalObject.globalContextInitialPromise;
     const globalContext = await globalObject.globalContextPromise;
+    (0, utils_js_1.assert)(globalContext);
+    (0, utils_js_1.checkType)(globalContext);
     return globalContext;
 }
 function getGlobalContextSync() {
     const { globalContext } = globalObject;
     (0, utils_js_1.assertUsage)(globalContext, createGlobalContextShared_js_1.getGlobalContextSyncErrMsg);
+    (0, utils_js_1.checkType)(globalContext);
     return globalContext;
 }

package/dist/cjs/client/shared/utils.js

@@ -20,3 +20,4 @@ __exportStar(require("../../utils/getGlobalObject.js"), exports);
 __exportStar(require("../../utils/objectAssign.js"), exports);
 __exportStar(require("../../utils/hasProp.js"), exports);
 __exportStar(require("../../utils/genPromise.js"), exports);
+__exportStar(require("../../utils/checkType.js"), exports);

package/dist/cjs/node/runtime/globalContext.js

@@ -21,6 +21,12 @@ exports.setGlobalContext_buildEntry = setGlobalContext_buildEntry;
 exports.clearGlobalContext = clearGlobalContext;
 exports.assertBuildInfo = assertBuildInfo;
 exports.updateUserFiles = updateUserFiles;
+// TODO/now: use isProductionEnvironment() instead of globalObject.isProduction
+// TODO/now: rename:
+//  - isProduction => isProductionEnvironment
+//  - setIsProduction => setIsProductionEnvironment
+//  - setGlobalContext_isProduction => setGlobalContext_isProductionEnvironment
+//  - sProductionEnvironment => sDevEnv
 // The core logic revolves around:
 // - virtualFileExports is the main requirement
 // - In production: globalObject.buildEntry which is the production entry set by @brillout/vite-plugin-server-entry
@@ -48,6 +54,7 @@ const globalObject = (0, utils_js_1.getGlobalObject)('runtime/globalContext.ts',
 const globalObjectTyped = globalObject;
 const vikeConfigErrorRecoverMsg = picocolors_1.default.bold(picocolors_1.default.green('Vike config loaded'));
 exports.vikeConfigErrorRecoverMsg = vikeConfigErrorRecoverMsg;
+(0, utils_js_1.assertIsNotBrowser)();
 async function getGlobalContextServerInternal() {
     // getGlobalContextServerInternal() should always be called after initGlobalContext()
     (0, utils_js_1.assert)(globalObject.isInitialized);
@@ -134,10 +141,12 @@ async function setGlobalContext_viteDevServer(viteDevServer) {
     (0, utils_js_1.assert)(globalObject.viteConfig);
     globalObject.viteDevServer = viteDevServer;
     globalObject.viteDevServerPromiseResolve(viteDevServer);
-    const { success } = await updateUserFiles();
-    if (!success)
-        return;
-    assertGlobalContextIsDefined();
+    if (isRunnable(viteDevServer)) {
+        const { success } = await updateUserFiles();
+        if (!success)
+            return;
+        assertGlobalContextIsDefined();
+    }
 }
 function setGlobalContext_viteConfig(viteConfig, viteConfigRuntime) {
     if (globalObject.viteConfig)
@@ -154,6 +163,7 @@ function setGlobalContext_isPrerendering() {
     globalObject.isPrerendering = true;
     setIsProduction(true);
 }
+// TODO/now: `rename tolerateContraditction tolerateContradiction`
 function setGlobalContext_isProduction(isProduction, tolerateContraditction = false) {
     if (debug.isActivated)
         debug('setGlobalContext_isProduction()', { isProduction, tolerateContraditction });
@@ -205,7 +215,13 @@ async function initGlobalContext() {
     const { isProduction } = globalObject;
     (0, utils_js_1.assert)(typeof isProduction === 'boolean');
     if (!isProduction) {
-        await globalObject.viteDevServerPromise;
+        if (isProcessSharedWithVite()) {
+            await globalObject.viteDevServerPromise;
+        }
+        else {
+            (0, utils_js_1.assert)(isNonRunnableDev());
+            await updateUserFiles();
+        }
         (0, utils_js_1.assert)(globalObject.waitForUserFilesUpdate);
         await globalObject.waitForUserFilesUpdate;
     }
@@ -262,7 +278,7 @@ async function loadBuildEntry(outDir) {
     assertBuildEntry(buildEntry);
     globalObject.assetsManifest = buildEntry.assetsManifest;
     globalObject.buildInfo = buildEntry.buildInfo;
-    await setGlobalContext(buildEntry.virtualFileExports);
+    await createGlobalContext(buildEntry.virtualFileExports);
 }
 // This is the production entry, see:
 // https://github.com/vikejs/vike/blob/798e5465dc3e3e6723b38b601a50350c0a006fb8/packages/vike/node/vite/plugins/pluginBuild/pluginBuildEntry.ts#L47
@@ -307,6 +323,7 @@ function assertVersionAtBuildTime(versionAtBuildTime) {
     (0, utils_js_1.assertUsage)(versionAtBuildTime === versionAtRuntime, `Re-build your app (you're using ${pretty(versionAtRuntime)} but your app was built with ${pretty(versionAtBuildTime)})`);
 }
 async function updateUserFiles() {
+    debug('updateUserFiles()');
     (0, utils_js_1.assert)(!globalObject.isProduction);
     const { promise, resolve } = (0, utils_js_1.genPromise)();
     globalObject.waitForUserFilesUpdate = promise;
@@ -339,16 +356,46 @@ async function updateUserFiles() {
         // Avoid race condition: abort if there is a new globalObject.viteDevServer (happens when vite.config.js is modified => Vite's dev server is fully reloaded).
         viteDevServer !== globalObject.viteDevServer;
     const { viteDevServer } = globalObject;
-    (0, utils_js_1.assert)(viteDevServer);
     let hasError = false;
     let virtualFileExports;
     let err;
-    try {
-        virtualFileExports = await viteDevServer.ssrLoadModule(virtualFileEntry_js_1.virtualFileIdEntryServer);
+    if (viteDevServer) {
+        (0, utils_js_1.assert)(isRunnable(viteDevServer));
+        /* We don't use runner.import() yet, because as of vite@7.0.6 (July 2025) runner.import() unexpectedly invalidates the module graph, which is a unexpected behavior that doesn't happen with ssrLoadModule()
+        // Vite 6
+        try {
+          virtualFileExports = await (viteDevServer.environments.ssr as RunnableDevEnvironment).runner.import(
+            'virtual:vike:entry:server',
+          )
+        } catch (err_) {
+          hasError = true
+          err = err_
+        }
+        */
+        // Vite 5
+        try {
+            virtualFileExports = await viteDevServer.ssrLoadModule(virtualFileEntry_js_1.virtualFileIdEntryServer);
+        }
+        catch (err_) {
+            hasError = true;
+            err = err_;
+        }
     }
-    catch (err_) {
-        hasError = true;
-        err = err_;
+    else {
+        try {
+            /* We use __VIKE__DYNAMIC_IMPORT instead of directly using import() to workaround what seems to be a Vite HMR bug:
+               ```js
+               assert(false)
+               // This line breaks the HMR of regular (runnable) apps, even though (as per the assert() above) it's never run. It seems to be a Vite bug: handleHotUpdate() receives an empty `modules` list.
+               import('virtual:vike:entry:server')
+               ```
+            */
+            virtualFileExports = await __VIKE__DYNAMIC_IMPORT('virtual:vike:entry:server');
+        }
+        catch (err_) {
+            hasError = true;
+            err = err_;
+        }
     }
     if (isOutdated())
         return { success: false };
@@ -359,7 +406,7 @@ async function updateUserFiles() {
         return { success: false };
     }
     try {
-        await setGlobalContext(virtualFileExports);
+        await createGlobalContext(virtualFileExports);
     }
     catch (err_) {
         hasError = true;
@@ -371,17 +418,17 @@ async function updateUserFiles() {
         return onError(err);
     return onSuccess();
 }
-async function setGlobalContext(virtualFileExports) {
-    debug('setGlobalContext()');
+async function createGlobalContext(virtualFileExports) {
+    debug('createGlobalContext()');
     (0, utils_js_1.assert)(!(0, getVikeConfigError_js_1.getVikeConfigErrorBuild)());
-    const globalContext = await (0, createGlobalContextShared_js_1.createGlobalContextShared)(virtualFileExports, globalObject, addGlobalContext, addGlobalContextTmp);
+    const globalContext = await (0, createGlobalContextShared_js_1.createGlobalContextShared)(virtualFileExports, globalObject, addGlobalContext, addGlobalContextTmp, addGlobalContextAsync);
     (0, assertV1Design_js_1.assertV1Design)(
     // pageConfigs is PageConfigRuntime[] but assertV1Design() requires PageConfigBuildTime[]
     globalContext._pageConfigs.length > 0, globalContext._pageFilesAll);
     assertGlobalContextIsDefined();
     (0, utils_js_1.onSetupRuntime)();
-    debug('setGlobalContext() - done');
-    // Never actually used, only used for TypeScript `ReturnType<typeof setGlobalContext>`
+    debug('createGlobalContext() - done');
+    // Never actually used, only used for TypeScript `ReturnType<typeof createGlobalContext>`
     return globalContext;
 }
 async function addGlobalContextTmp(globalContext) {
@@ -400,23 +447,18 @@ function addGlobalContextCommon(globalContext, pageRoutes, onBeforeRouteHook) {
         _pageRoutes: pageRoutes,
         _onBeforeRouteHook: onBeforeRouteHook,
     };
-    const { viteDevServer, viteConfig, viteConfigRuntime, isPrerendering, isProduction } = globalObject;
+    const { viteDevServer, viteConfig, isPrerendering, isProduction } = globalObject;
     (0, utils_js_1.assert)(typeof isProduction === 'boolean');
     if (!isProduction) {
-        (0, utils_js_1.assert)(viteDevServer);
         (0, utils_js_1.assert)(globalContext); // main common requirement
-        (0, utils_js_1.assert)(viteConfig);
-        (0, utils_js_1.assert)(viteConfigRuntime);
         (0, utils_js_1.assert)(!isPrerendering);
         return {
             ...globalContextBase,
-            ...resolveBaseRuntime(viteConfigRuntime, globalContext.config),
             _isProduction: false,
             _isPrerendering: false,
             assetsManifest: null,
             _viteDevServer: viteDevServer,
             viteConfig,
-            viteConfigRuntime,
         };
     }
     else {
@@ -427,11 +469,9 @@ function addGlobalContextCommon(globalContext, pageRoutes, onBeforeRouteHook) {
         (0, utils_js_1.assert)(assetsManifest);
         const globalContextBase2 = {
             ...globalContextBase,
-            ...resolveBaseRuntime(buildInfo.viteConfigRuntime, globalContext.config),
             _isProduction: true,
             assetsManifest,
             _viteDevServer: null,
-            viteConfigRuntime: buildInfo.viteConfigRuntime,
             _usesClientRouter: buildInfo.usesClientRouter,
         };
         if (isPrerendering) {
@@ -451,6 +491,27 @@ function addGlobalContextCommon(globalContext, pageRoutes, onBeforeRouteHook) {
         }
     }
 }
+async function addGlobalContextAsync(globalContext) {
+    debug('addGlobalContextAsync()');
+    let { viteConfigRuntime, buildInfo } = globalObject;
+    if (!viteConfigRuntime) {
+        if (buildInfo) {
+            viteConfigRuntime = buildInfo.viteConfigRuntime;
+        }
+        else {
+            (0, utils_js_1.assert)(!isProcessSharedWithVite()); // process shared with Vite => globalObject.viteConfigRuntime should be set
+            (0, utils_js_1.assert)(!globalObject.isProduction); // production => globalObject.buildInfo.viteConfigRuntime should be set
+            (0, utils_js_1.assert)(isNonRunnableDev());
+            const rpc = (0, utils_js_1.getViteRPC)();
+            viteConfigRuntime = await rpc.getViteConfigRuntimeRPC();
+        }
+    }
+    (0, utils_js_1.assert)(viteConfigRuntime);
+    return {
+        viteConfigRuntime,
+        ...resolveBaseRuntime(viteConfigRuntime, globalContext.config),
+    };
+}
 function clearGlobalContext() {
     debug('clearGlobalContext()');
     (0, utils_js_1.objectReplace)(globalObject, getInitialGlobalObject(), ['buildEntryPrevious']);
@@ -459,6 +520,7 @@ function getInitialGlobalObject() {
     debug('getInitialGlobalObject()');
     const { promise: viteDevServerPromise, resolve: viteDevServerPromiseResolve } = (0, utils_js_1.genPromise)();
     return {
+        isProduction: isNonRunnableDev() ? false : undefined,
         viteDevServerPromise,
         viteDevServerPromiseResolve,
     };
@@ -469,3 +531,26 @@ function resolveBaseRuntime(viteConfigRuntime, config) {
     const baseAssetsUnresolved = config.baseAssets ?? null;
     return (0, resolveBase_js_1.resolveBase)(baseViteOriginal, baseServerUnresolved, baseAssetsUnresolved);
 }
+function isProcessSharedWithVite() {
+    const yes = globalThis.__VIKE__IS_PROCESS_SHARED_WITH_VITE ?? false;
+    if (yes)
+        (0, utils_js_1.assert)(!isNonRunnableDev());
+    return yes;
+}
+function isRunnable(viteDevServer) {
+    const yes = 
+    // Vite 5
+    !viteDevServer.environments ||
+        // Vite 6 or above
+        (0, utils_js_1.isRunnableDevEnvironment)(viteDevServer.environments.ssr);
+    if (yes)
+        (0, utils_js_1.assert)(!isNonRunnableDev());
+    return yes;
+}
+function isNonRunnableDev() {
+    if (typeof __VIKE__IS_NON_RUNNABLE_DEV === 'undefined')
+        return null;
+    const yes = __VIKE__IS_NON_RUNNABLE_DEV;
+    (0, utils_js_1.assert)(typeof yes === 'boolean');
+    return yes;
+}

package/dist/cjs/node/runtime/html/injectAssets/getViteDevScript.js

@@ -16,7 +16,9 @@ async function getViteDevScript(pageContext) {
     const fakeHtmlBegin = '<html> <head>'; // White space to test whether user is using a minifier
     const fakeHtmlEnd = '</head><body></body></html>';
     let fakeHtml = fakeHtmlBegin + fakeHtmlEnd;
-    fakeHtml = await viteDevServer.transformIndexHtml('/', fakeHtml);
+    fakeHtml = viteDevServer
+        ? await viteDevServer.transformIndexHtml('/', fakeHtml)
+        : await (0, utils_js_1.getViteRPC)().transformIndexHtmlRPC(fakeHtml);
     (0, utils_js_1.assertUsage)(!fakeHtml.includes('vite-plugin-pwa'), `The HTML transformer of ${picocolors_1.default.cyan('vite-plugin-pwa')} cannot be applied, see workaround at https://github.com/vikejs/vike/issues/388#issuecomment-1199280084`);
     (0, utils_js_1.assertUsage)(!fakeHtml.startsWith(fakeHtmlBegin.replace(' ', '')), `Vite plugins that minify the HTML cannot be applied, see https://github.com/vikejs/vike/issues/224`);
     (0, utils_js_1.assertUsage)(fakeHtml.startsWith(fakeHtmlBegin) && fakeHtml.endsWith(fakeHtmlEnd), `You are using a Vite Plugin that transforms the HTML in a way that conflicts with Vike. ${reachOutCTA}`);

package/dist/cjs/node/runtime/renderPage/getPageAssets.js

@@ -17,7 +17,9 @@ async function getPageAssets(pageContext, clientDependencies, clientEntries) {
     const { _isProduction: isProduction } = globalContext;
     const isDev = !isProduction;
     const { assetUrls, clientEntriesSrc } = isDev
-        ? await retrievePageAssetsDev(globalContext._viteDevServer, clientDependencies, clientEntries)
+        ? !globalContext._viteDevServer
+            ? await (0, utils_js_1.getViteRPC)().retrievePageAssetsDevRPC(clientDependencies, clientEntries)
+            : await retrievePageAssetsDev(globalContext._viteDevServer, clientDependencies, clientEntries)
         : retrievePageAssetsProd(globalContext.assetsManifest, clientDependencies, clientEntries, resolveIncludeAssetsImportedByServer(globalContext.config));
     let pageAssets = [];
     (0, utils_js_1.unique)([...clientEntriesSrc, ...assetUrls]).forEach((src) => {

package/dist/cjs/node/runtime/utils.js

@@ -77,3 +77,6 @@ __exportStar(require("../../utils/PROJECT_VERSION.js"), exports);
 __exportStar(require("../../utils/genPromise.js"), exports);
 __exportStar(require("../../utils/augmentType.js"), exports);
 __exportStar(require("../../utils/changeEnumerable.js"), exports);
+__exportStar(require("../../utils/getViteRPC.js"), exports);
+__exportStar(require("../../utils/isRunnableDevEnvironment.js"), exports);
+__exportStar(require("../../utils/assertIsNotBrowser.js"), exports);

package/dist/cjs/node/vite/index.js

@@ -29,6 +29,7 @@ const resolveClientEntriesDev_js_1 = require("./shared/resolveClientEntriesDev.j
 const pluginWorkaroundCssModuleHmr_js_1 = require("./plugins/pluginWorkaroundCssModuleHmr.js");
 const pluginWorkaroundVite6HmrRegression_js_1 = require("./plugins/pluginWorkaroundVite6HmrRegression.js");
 const pluginReplaceConstants_js_1 = require("./plugins/pluginReplaceConstants.js");
+const pluginNonRunnableDev_js_1 = require("./plugins/pluginNonRunnableDev.js");
 // We don't call this in ./onLoad.ts to avoid a cyclic dependency with utils.ts
 (0, getPageAssets_js_1.setResolveClientEntriesDev)(resolveClientEntriesDev_js_1.resolveClientEntriesDev);
 // Return `PluginInterop` instead of `Plugin` to avoid type mismatch upon different Vite versions
@@ -48,6 +49,7 @@ function plugin(vikeVitePluginOptions = {}) {
         (0, pluginWorkaroundCssModuleHmr_js_1.pluginWorkaroundCssModuleHmr)(),
         (0, pluginWorkaroundVite6HmrRegression_js_1.pluginWorkaroundVite6HmrRegression)(),
         (0, pluginReplaceConstants_js_1.pluginReplaceConstants)(),
+        (0, pluginNonRunnableDev_js_1.pluginNonRunnableDev)(),
     ];
     Object.assign(plugins, { _vikeVitePluginOptions: vikeVitePluginOptions });
     return plugins;

package/dist/cjs/node/vite/plugins/pluginBuild/handleAssetsManifest.js

@@ -14,13 +14,13 @@ const node_path_1 = __importDefault(require("node:path"));
 const node_fs_2 = require("node:fs");
 const utils_js_1 = require("../../utils.js");
 const virtualFilePageConfigLazy_js_1 = require("../../../shared/virtualFiles/virtualFilePageConfigLazy.js");
-const pluginBuildConfig_js_1 = require("./pluginBuildConfig.js");
 const getAssetsDir_js_1 = require("../../shared/getAssetsDir.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const resolveVikeConfigInternal_js_1 = require("../../shared/resolveVikeConfigInternal.js");
 const getOutDirs_js_1 = require("../../shared/getOutDirs.js");
 const isViteServerBuild_js_1 = require("../../shared/isViteServerBuild.js");
 const pluginBuildEntry_js_1 = require("./pluginBuildEntry.js");
+const getManifestFilePathRelative_js_1 = require("../../shared/getManifestFilePathRelative.js");
 (0, utils_js_1.assertIsSingleModuleInstance)('build/handleAssetsManifest.ts');
 let assetsJsonFilePath;
 // true  => use workaround config.build.ssrEmitAssets
@@ -31,9 +31,8 @@ function handleAssetsManifest_isFixEnabled(config) {
 }
 /** https://github.com/vikejs/vike/issues/1339 */
 async function fixServerAssets(config) {
-    const outDirs = (0, getOutDirs_js_1.getOutDirs)(config);
-    const clientManifest = await readManifestFile(outDirs.outDirClient);
-    const serverManifest = await readManifestFile(outDirs.outDirServer);
+    const clientManifest = await readManifestFile(config, true);
+    const serverManifest = await readManifestFile(config, false);
     const { clientManifestMod, serverManifestMod, filesToMove, filesToRemove } = addServerAssets(clientManifest, serverManifest);
     await copyAssets(filesToMove, filesToRemove, config);
     return { clientManifestMod, serverManifestMod };
@@ -270,8 +269,8 @@ function removeEmptyDirectories(dirPath) {
         node_fs_1.default.rmdirSync(dirPath);
     }
 }
-async function readManifestFile(outDir) {
-    const manifestFilePath = node_path_1.default.posix.join(outDir, pluginBuildConfig_js_1.manifestTempFile);
+async function readManifestFile(config, client) {
+    const manifestFilePath = getManifestFilePath(config, client);
     const manifestFileContent = await promises_1.default.readFile(manifestFilePath, 'utf-8');
     (0, utils_js_1.assert)(manifestFileContent);
     const manifest = JSON.parse(manifestFileContent);
@@ -292,7 +291,7 @@ async function handleAssetsManifest_getBuildConfig(config) {
         ssrEmitAssets: isFixEnabled ? true : undefined,
         // Required if `ssrEmitAssets: true`, see https://github.com/vitejs/vite/pull/11430#issuecomment-1454800934
         cssMinify: isFixEnabled ? 'esbuild' : undefined,
-        manifest: pluginBuildConfig_js_1.manifestTempFile,
+        manifest: true,
         copyPublicDir: vikeConfig.config.vite6BuilderApp
             ? // Already set by vike:build:pluginBuildApp
                 undefined
@@ -305,7 +304,7 @@ async function handleAssetsManifest(config, viteEnv, options, bundle) {
         (0, utils_js_1.assert)(!assetsJsonFilePath);
         const outDirs = (0, getOutDirs_js_1.getOutDirs)(config, viteEnv);
         assetsJsonFilePath = node_path_1.default.posix.join(outDirs.outDirRoot, 'assets.json');
-        await writeAssetsManifestFile(outDirs, assetsJsonFilePath, config);
+        await writeAssetsManifestFile(assetsJsonFilePath, config);
     }
     if ((0, isViteServerBuild_js_1.isViteServerBuild)(config, viteEnv)) {
         const outDir = options.dir;
@@ -319,10 +318,10 @@ async function handleAssetsManifest(config, viteEnv, options, bundle) {
             (0, utils_js_1.assert)(!noop); // dist/server should always contain __VITE_ASSETS_MANIFEST__
     }
 }
-async function writeAssetsManifestFile(outDirs, assetsJsonFilePath, config) {
+async function writeAssetsManifestFile(assetsJsonFilePath, config) {
     const isFixEnabled = handleAssetsManifest_isFixEnabled(config);
-    const clientManifestFilePath = node_path_1.default.posix.join(outDirs.outDirClient, pluginBuildConfig_js_1.manifestTempFile);
-    const serverManifestFilePath = node_path_1.default.posix.join(outDirs.outDirServer, pluginBuildConfig_js_1.manifestTempFile);
+    const clientManifestFilePath = getManifestFilePath(config, true);
+    const serverManifestFilePath = getManifestFilePath(config, false);
     if (!isFixEnabled) {
         await promises_1.default.copyFile(clientManifestFilePath, assetsJsonFilePath);
     }
@@ -333,3 +332,12 @@ async function writeAssetsManifestFile(outDirs, assetsJsonFilePath, config) {
     await promises_1.default.rm(clientManifestFilePath);
     await promises_1.default.rm(serverManifestFilePath);
 }
+function getManifestFilePath(config, client) {
+    const outDirs = (0, getOutDirs_js_1.getOutDirs)(config);
+    const outDir = client ? outDirs.outDirClient : outDirs.outDirServer;
+    const env = client ? config.environments.client : config.environments.ssr;
+    (0, utils_js_1.assert)(env);
+    const manifestFilePathRelative = (0, getManifestFilePathRelative_js_1.getManifestFilePathRelative)(env.build.manifest);
+    const manifestFilePath = node_path_1.default.posix.join(outDir, manifestFilePathRelative);
+    return manifestFilePath;
+}

package/dist/cjs/node/vite/plugins/pluginBuild/pluginAutoFullBuild.js

@@ -11,12 +11,12 @@ const context_js_1 = require("../../../prerender/context.js");
 const isViteCliCall_js_1 = require("../../shared/isViteCliCall.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const logErrorHint_js_1 = require("../../../runtime/renderPage/logErrorHint.js");
-const pluginBuildConfig_js_1 = require("./pluginBuildConfig.js");
 const resolveVikeConfigInternal_js_1 = require("../../shared/resolveVikeConfigInternal.js");
 const context_js_2 = require("../../../api/context.js");
 const handleAssetsManifest_js_1 = require("./handleAssetsManifest.js");
 const isViteServerBuild_js_1 = require("../../shared/isViteServerBuild.js");
 const runPrerenderEntry_js_1 = require("../../../prerender/runPrerenderEntry.js");
+const getManifestFilePathRelative_js_1 = require("../../shared/getManifestFilePathRelative.js");
 (0, utils_js_1.assertIsSingleModuleInstance)('build/pluginAutoFullBuild.ts');
 let forceExit = false;
 function pluginAutoFullBuild() {
@@ -87,7 +87,7 @@ async function triggerFullBuild(config, viteEnv, bundle) {
     //  - The legacy plugin triggers its own Rollup build for the client-side.
     //  - The legacy plugin doesn't generate a manifest => we can use that to detect the legacy plugin build.
     //  - Issue & reproduction: https://github.com/vikejs/vike/issues/1154#issuecomment-1965954636
-    if (!bundle[pluginBuildConfig_js_1.manifestTempFile])
+    if (!bundle[(0, getManifestFilePathRelative_js_1.getManifestFilePathRelative)(config.build.manifest)])
         return;
     const configInline = getFullBuildInlineConfig(config);
     if (!isBuilderApp) {

package/dist/cjs/node/vite/plugins/pluginBuild/pluginBuildConfig.js

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.manifestTempFile = void 0;
 exports.pluginBuildConfig = pluginBuildConfig;
 exports.assertRollupInput = assertRollupInput;
 exports.analyzeClientEntries = analyzeClientEntries;
@@ -16,8 +15,6 @@ const isViteServerBuild_js_1 = require("../../shared/isViteServerBuild.js");
 const getOutDirs_js_1 = require("../../shared/getOutDirs.js");
 const handleAssetsManifest_js_1 = require("./handleAssetsManifest.js");
 const getPageAssets_js_1 = require("../../../runtime/renderPage/getPageAssets.js");
-const manifestTempFile = '_temp_manifest.json';
-exports.manifestTempFile = manifestTempFile;
 function pluginBuildConfig() {
     let config;
     return [

package/dist/cjs/node/vite/plugins/pluginCommon.js

@@ -16,6 +16,7 @@ const resolveVikeConfigInternal_js_1 = require("../shared/resolveVikeConfigInter
 const prepareViteApiCall_js_1 = require("../../api/prepareViteApiCall.js");
 const context_js_2 = require("../../prerender/context.js");
 const pluginName = 'vike:pluginCommon';
+globalThis.__VIKE__IS_PROCESS_SHARED_WITH_VITE = true;
 function pluginCommon(vikeVitePluginOptions) {
     return [
         {

package/dist/cjs/node/vite/plugins/pluginDev/determineOptimizeDeps.js

@@ -14,21 +14,23 @@ async function determineOptimizeDeps(config) {
     const { entriesClient, entriesServer, includeClient, includeServer } = await getPageDeps(config, pageConfigs);
     config.optimizeDeps.include = add(config.optimizeDeps.include, includeClient);
     config.optimizeDeps.entries = add(config.optimizeDeps.entries, entriesClient);
-    // TO-DO/eventually: use a check that is agnostic to @cloudflare/vite-plugin
-    const isNotRunnable = config.environments?.ssr?.resolve.conditions.includes('workerd');
-    if (isNotRunnable) {
-        config.ssr.optimizeDeps.include = add(config.ssr.optimizeDeps.include, includeServer);
-        // @ts-ignore — Vite doesn't seem to support ssr.optimizeDeps.entries (vite@7.0.6, July 2025)
-        config.ssr.optimizeDeps.entries = add(config.ssr.optimizeDeps.entries, entriesServer);
+    // Workaround until https://github.com/vitejs/vite-plugin-react/issues/650
+    // - TODO/soon: remove workaround once https://github.com/vitejs/vite/pull/20495 is released
+    includeServer.push('react/jsx-dev-runtime');
+    for (const envName in config.environments) {
+        const env = config.environments[envName];
+        if (env.consumer === 'server' && env.optimizeDeps.noDiscovery === false) {
+            env.optimizeDeps.include = add(env.optimizeDeps.include, includeServer);
+            env.optimizeDeps.entries = add(env.optimizeDeps.entries, entriesServer);
+        }
     }
     if (debug.isActivated)
         debug('optimizeDeps', {
             'config.optimizeDeps.entries': config.optimizeDeps.entries,
             'config.optimizeDeps.include': config.optimizeDeps.include,
             'config.optimizeDeps.exclude': config.optimizeDeps.exclude,
-            /* Vite doesn't seem to support ssr.optimizeDeps.entries (vite@7.0.6, July 2025)
+            // @ts-ignore Vite doesn't seem to support ssr.optimizeDeps.entries (vite@7.0.6, July 2025)
             'config.ssr.optimizeDeps.entries': config.ssr.optimizeDeps.entries,
-            //*/
             'config.ssr.optimizeDeps.include': config.ssr.optimizeDeps.include,
             'config.ssr.optimizeDeps.exclude': config.ssr.optimizeDeps.exclude,
         });

package/dist/cjs/node/vite/plugins/pluginEnvVars.js

@@ -12,7 +12,7 @@ const normalizeId_js_1 = require("../shared/normalizeId.js");
 const isViteServerBuild_js_1 = require("../shared/isViteServerBuild.js");
 const applyRegExWithMagicString_js_1 = require("../shared/applyRegExWithMagicString.js");
 // TO-DO/eventually:
-// - Make import.meta.env work inside +config.js
+// - Make ({}) work inside +config.js
 //   - For it to work, we'll probably need the user to define the settings (e.g. `envDir`) for loadEnv() inside vike.config.js instead of vite.config.js
 //   - Or stop using Vite's `mode` implementation and have Vike implement its own `mode` feature? (So that the only dependencies are `$ vike build --mode staging` and `$ MODE=staging vike build`.)
 const PUBLIC_ENV_PREFIX = 'PUBLIC_ENV__';
@@ -39,7 +39,7 @@ function pluginEnvVars() {
             (0, utils_js_1.assertPosixPath)(config.root);
             if (!id.startsWith(config.root))
                 return;
-            if (!code.includes('import.meta.env.'))
+            if (!code.includes('({}).'))
                 return;
             const isBuild = config.command === 'build';
             const isClientSide = !(0, isViteServerBuild_js_1.isViteServerBuild_safe)(config, options);
@@ -52,7 +52,7 @@ function pluginEnvVars() {
                 return !envPrefix.some((prefix) => key.startsWith(prefix));
             })
                 .map(([envName, envVal]) => {
-                const envStatement = `import.meta.env.${envName}`;
+                const envStatement = `({}).${envName}`;
                 const envStatementRegExpStr = (0, utils_js_1.escapeRegex)(envStatement) + '\\b';
                 // Security check
                 {

package/dist/cjs/node/vite/plugins/pluginExtractExportNames.js

@@ -81,12 +81,12 @@ function injectHmr(code, isClientSide, isProduction) {
     }
     if (isClientSide) {
         code += '\n';
-        code += `if (import.meta.hot) import.meta.hot.accept((mod) => { exportNames.length=0; exportNames.push(...mod.exportNames); });`;
+        code += `if ((undefined)) (undefined).accept((mod) => { exportNames.length=0; exportNames.push(...mod.exportNames); });`;
     }
     else {
         // Ensure Vite considers the module as `isSelfAccepting`. (Needed because Vite's module graph erroneously conflates the Vite server-side modules with their client-side counterparts.)
         code += '\n';
-        code += 'if(false){import.meta.hot.accept(()=>{})};';
+        code += 'if(false){(undefined).accept(()=>{})};';
     }
     return code;
 }

package/dist/cjs/node/vite/plugins/pluginNonRunnableDev.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pluginNonRunnableDev = pluginNonRunnableDev;
+const utils_js_1 = require("../utils.js");
+const resolveClientEntriesDev_js_1 = require("../shared/resolveClientEntriesDev.js");
+const retrieveAssetsDev_js_1 = require("../../runtime/renderPage/getPageAssets/retrieveAssetsDev.js");
+const getViteConfigRuntime_js_1 = require("../shared/getViteConfigRuntime.js");
+const getMagicString_js_1 = require("../shared/getMagicString.js");
+(0, utils_js_1.assertIsNotProductionRuntime)();
+function getViteRpcFunctions(viteDevServer) {
+    return {
+        async transformIndexHtmlRPC(html) {
+            return await viteDevServer.transformIndexHtml('/', html);
+        },
+        // TODO/now: dedupe retrievePageAssetsDevRPC and retrievePageAssetsDev()
+        async retrievePageAssetsDevRPC(clientDependencies, clientEntries) {
+            const clientEntriesSrc = clientEntries.map((clientEntry) => (0, resolveClientEntriesDev_js_1.resolveClientEntriesDev)(clientEntry, viteDevServer));
+            const assetUrls = await (0, retrieveAssetsDev_js_1.retrieveAssetsDev)(clientDependencies, viteDevServer);
+            return { clientEntriesSrc, assetUrls };
+        },
+        async getViteConfigRuntimeRPC() {
+            return (0, getViteConfigRuntime_js_1.getViteConfigRuntime)(viteDevServer.config);
+        },
+    };
+}
+function pluginNonRunnableDev() {
+    const runtimeGlobalContextFilePath = (0, utils_js_1.requireResolveVikeDistFile)('dist/esm/node/runtime/globalContext.js');
+    let config;
+    return {
+        name: 'vike:pluginNonRunnableDev',
+        configureServer(viteDevServer) {
+            (0, utils_js_1.createViteRPC)(viteDevServer, getViteRpcFunctions);
+        },
+        configResolved(config_) {
+            config = config_;
+        },
+        transform(code, id) {
+            if (!config._isDev)
+                return;
+            if (id !== runtimeGlobalContextFilePath)
+                return;
+            const isNonRunnableDev = !(0, utils_js_1.isRunnableDevEnvironment)(this.environment);
+            const { magicString, getMagicStringResult } = (0, getMagicString_js_1.getMagicString)(code, id);
+            if (isNonRunnableDev) {
+                magicString.replaceAll('__VIKE__DYNAMIC_IMPORT', 'import');
+            }
+            magicString.replaceAll('__VIKE__IS_NON_RUNNABLE_DEV', JSON.stringify(isNonRunnableDev));
+            return getMagicStringResult();
+        },
+    };
+}