vike 0.4.236 → 0.4.237-commit-8749e81

package/dist/cjs/client/runtime-client-routing/globalContext.js

@@ -37,8 +37,8 @@ exports.getGlobalContextClientInternal = void 0;
 const createGetGlobalContextClient_js_1 = require("../shared/createGetGlobalContextClient.js");
 const loadPageRoutes_js_1 = require("../../shared/route/loadPageRoutes.js");
 // @ts-ignore
-const virtualFileExports = __importStar(require("virtual:vike:entry:client:client-routing"));
-const getGlobalContextClientInternal = (0, createGetGlobalContextClient_js_1.createGetGlobalContextClient)(virtualFileExports, true, addGlobalContext);
+const virtualFileExportsGlobalEntry = __importStar(require("virtual:vike:global-entry:client:client-routing"));
+const getGlobalContextClientInternal = (0, createGetGlobalContextClient_js_1.createGetGlobalContextClient)(virtualFileExportsGlobalEntry, true, addGlobalContext);
 exports.getGlobalContextClientInternal = getGlobalContextClientInternal;
 async function addGlobalContext(globalContext) {
     const { pageRoutes, onBeforeRouteHook } = await (0, loadPageRoutes_js_1.loadPageRoutes)(globalContext._pageFilesAll, globalContext._pageConfigs, globalContext._pageConfigGlobal, globalContext._allPageIds);

package/dist/cjs/client/runtime-server-routing/globalContext.js

@@ -36,6 +36,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getGlobalContextClientInternal = void 0;
 const createGetGlobalContextClient_js_1 = require("../shared/createGetGlobalContextClient.js");
 // @ts-ignore
-const virtualFileExports = __importStar(require("virtual:vike:entry:client:server-routing"));
-const getGlobalContextClientInternal = (0, createGetGlobalContextClient_js_1.createGetGlobalContextClient)(virtualFileExports, false);
+const virtualFileExportsGlobalEntry = __importStar(require("virtual:vike:global-entry:client:server-routing"));
+const getGlobalContextClientInternal = (0, createGetGlobalContextClient_js_1.createGetGlobalContextClient)(virtualFileExportsGlobalEntry, false);
 exports.getGlobalContextClientInternal = getGlobalContextClientInternal;

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

@@ -7,32 +7,34 @@ 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) {
+function createGetGlobalContextClient(virtualFileExportsGlobalEntry, isClientRouting, addGlobalContext) {
     (0, utils_js_1.assert)(globalObject.isClientRouting === undefined || globalObject.isClientRouting === isClientRouting);
     globalObject.isClientRouting = isClientRouting;
     // Eagerly call onCreateGlobalContext() hook
     getGlobalContext();
     return getGlobalContext;
     async function getGlobalContext() {
-        // Cache
-        if (globalObject.globalContext &&
-            // Don't break HMR
-            globalObject.globalContext._virtualFileExports !== virtualFileExports) {
-            return globalObject.globalContext;
+        // HMR => virtualFileExportsGlobalEntry differ
+        if (globalObject.virtualFileExportsGlobalEntry === virtualFileExportsGlobalEntry) {
+            const globalContext = await globalObject.globalContextPromise;
+            return globalContext;
+        }
+        else {
+            globalObject.virtualFileExportsGlobalEntry = virtualFileExportsGlobalEntry;
         }
         // Create
-        const globalContext = await (0, createGlobalContextShared_js_1.createGlobalContextShared)(virtualFileExports, globalObject, async (globalContext) => {
+        const globalContextPromise = (0, createGlobalContextShared_js_1.createGlobalContextShared)(virtualFileExportsGlobalEntry, 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 +42,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/getJsonSerializedInHtml.js

@@ -26,6 +26,15 @@ function findAndParseJson(id) {
     `Couldn't find #${id} (which Vike automatically injects in the HTML): make sure it exists (i.e. don't remove it and make sure your HTML isn't malformed)`);
     const jsonStr = elem.textContent;
     (0, utils_js_1.assert)(jsonStr);
-    const json = (0, parse_1.parse)(jsonStr);
+    const json = (0, parse_1.parse)(jsonStr, {
+        // Prevent Google from crawling URLs in JSON:
+        // - https://github.com/vikejs/vike/pull/2603
+        // - https://github.com/brillout/json-serializer/blob/38edbb9945de4938da1e65d6285ce1dd123a45ef/test/main.spec.ts#L44-L95
+        reviver(_key, value) {
+            if (typeof value === 'string') {
+                return { replacement: value.replaceAll('\\/', '/'), resolved: false };
+            }
+        },
+    });
     return json;
 }

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/api/preview.js

@@ -21,7 +21,7 @@ async function preview(options = {}) {
     (0, utils_js_2.onSetupPreview)();
     const { viteConfigFromUserEnhanced, viteConfigResolved } = await (0, prepareViteApiCall_js_1.prepareViteApiCall)(options, 'preview');
     if (viteConfigResolved.vitePluginServerEntry?.inject) {
-        const outDir = (0, getOutDirs_js_1.getOutDirs)(viteConfigResolved).outDirRoot;
+        const outDir = (0, getOutDirs_js_1.getOutDirs)(viteConfigResolved, undefined).outDirRoot;
         const { outServerIndex } = await (0, runtime_1.importServerProductionIndex)({ outDir });
         const outServerIndexRelative = node_path_1.default.relative(viteConfigResolved.root, outServerIndex);
         (0, utils_js_1.assertWarning)(false, `Never run ${picocolors_1.default.cyan('$ vike preview')} in production, run ${picocolors_1.default.cyan(`$ node ${outServerIndexRelative}`)} instead (or Bun/Deno).`, { onlyOnce: true });

package/dist/cjs/node/prerender/runPrerender.js

@@ -53,7 +53,7 @@ const getPageFiles_js_1 = require("../../shared/getPageFiles.js");
 const getPageContextRequestUrl_js_1 = require("../../shared/getPageContextRequestUrl.js");
 const resolveRouteString_js_1 = require("../../shared/route/resolveRouteString.js");
 const getConfigValueRuntime_js_1 = require("../../shared/page-configs/getConfigValueRuntime.js");
-const loadConfigValues_js_1 = require("../../shared/page-configs/loadConfigValues.js");
+const loadPageEntry_js_1 = require("../../shared/page-configs/loadPageEntry.js");
 const error_page_js_1 = require("../../shared/error-page.js");
 const abort_js_1 = require("../../shared/route/abort.js");
 const loadPageConfigsLazyServerSide_js_1 = require("../runtime/renderPage/loadPageConfigsLazyServerSide.js");
@@ -82,7 +82,7 @@ async function runPrerender(options = {}, trigger) {
     await disableReactStreaming();
     const viteConfig = await (0, vite_1.resolveConfig)(options.viteConfig || {}, 'build', 'production');
     const vikeConfig = await (0, resolveVikeConfigInternal_js_1.getVikeConfigInternal)();
-    const { outDirServer } = (0, getOutDirs_js_1.getOutDirs)(viteConfig);
+    const { outDirServer } = (0, getOutDirs_js_1.getOutDirs)(viteConfig, undefined);
     const prerenderConfigGlobal = (0, resolvePrerenderConfig_js_1.resolvePrerenderConfigGlobal)(vikeConfig);
     const { partial, noExtraDir, parallel, defaultLocalValue, isPrerenderingEnabled } = prerenderConfigGlobal;
     if (!isPrerenderingEnabled) {
@@ -212,7 +212,7 @@ async function callOnBeforePrerenderStartHooks(prerenderContext, globalContext,
     // V1 design
     await Promise.all(globalContext._pageConfigs.map((pageConfig) => concurrencyLimit(async () => {
         const hookName = 'onBeforePrerenderStart';
-        const pageConfigLoaded = await (0, loadConfigValues_js_1.loadConfigValues)(pageConfig, false);
+        const pageConfigLoaded = await (0, loadPageEntry_js_1.loadPageEntry)(pageConfig, false);
         const hook = (0, getHook_js_1.getHookFromPageConfig)(pageConfigLoaded, hookName);
         if (!hook)
             return;
@@ -590,7 +590,7 @@ async function writeFiles({ pageContext, htmlString, pageContextSerialized }, vi
 async function write(pageContext, fileType, fileContent, viteConfig, onPagePrerender, prerenderContext, logLevel) {
     const { urlOriginal } = pageContext;
     (0, utils_js_1.assert)(urlOriginal.startsWith('/'));
-    const { outDirClient } = (0, getOutDirs_js_1.getOutDirs)(viteConfig);
+    const { outDirClient } = (0, getOutDirs_js_1.getOutDirs)(viteConfig, undefined);
     const { root } = viteConfig;
     let fileUrl;
     if (fileType === 'HTML') {

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

@@ -21,17 +21,23 @@ 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
+// - virtualFileExportsGlobalEntry is the main requirement
 // - In production: globalObject.buildEntry which is the production entry set by @brillout/vite-plugin-server-entry
-//   - loadBuildEntry() sets globalObject.buildEntry and then sets virtualFileExports
+//   - loadBuildEntry() sets globalObject.buildEntry and then sets virtualFileExportsGlobalEntry
 //   - With vike-server it's set at server start: @brillout/vite-plugin-server-entry injects `import './entry.mjs'` (the production entry generated by @brillout/vite-plugin-server-entry) as first line of code of dist/server/index.mjs while dist/server/entry.mjs calls setGlobalContext_buildEntry()
 //   - Without vike-server it's manually loaded here using importServerProductionEntry() which uses @brillout/vite-plugin-server-entry's autoImporter or crawler
 // - In development: globalObject.viteDevServer which is Vite's development server
-//   - globalObject.viteDevServer is used by updateUserFiles() which then sets virtualFileExports
+//   - globalObject.viteDevServer is used by updateUserFiles() which then sets virtualFileExportsGlobalEntry
 const utils_js_1 = require("./utils.js");
 const runtime_1 = require("@brillout/vite-plugin-server-entry/runtime");
-const virtualFileEntry_js_1 = require("../shared/virtualFiles/virtualFileEntry.js");
+const virtualFileId_js_1 = require("../shared/virtualFileId.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const loadPageRoutes_js_1 = require("../../shared/route/loadPageRoutes.js");
 const assertV1Design_js_1 = require("../shared/assertV1Design.js");
@@ -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,12 +163,14 @@ function setGlobalContext_isPrerendering() {
     globalObject.isPrerendering = true;
     setIsProduction(true);
 }
-function setGlobalContext_isProduction(isProduction, tolerateContraditction) {
+function setGlobalContext_isProduction(isProduction, tolerateContradiction = false) {
+    if (debug.isActivated)
+        debug('setGlobalContext_isProduction()', { isProduction, tolerateContradiction });
     if (globalObject.isProduction === undefined) {
         setIsProduction(isProduction);
     }
     else {
-        (0, utils_js_1.assert)(globalObject.isProduction === isProduction || tolerateContraditction);
+        (0, utils_js_1.assert)(globalObject.isProduction === isProduction || tolerateContradiction);
     }
 }
 function getViteDevServer() {
@@ -203,7 +214,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;
     }
@@ -260,7 +277,7 @@ async function loadBuildEntry(outDir) {
     assertBuildEntry(buildEntry);
     globalObject.assetsManifest = buildEntry.assetsManifest;
     globalObject.buildInfo = buildEntry.buildInfo;
-    await setGlobalContext(buildEntry.virtualFileExports);
+    await createGlobalContext(buildEntry.virtualFileExportsGlobalEntry);
 }
 // This is the production entry, see:
 // https://github.com/vikejs/vike/blob/798e5465dc3e3e6723b38b601a50350c0a006fb8/packages/vike/node/vite/plugins/pluginBuild/pluginBuildEntry.ts#L47
@@ -277,15 +294,15 @@ async function setGlobalContext_buildEntry(buildEntry) {
 }
 function assertBuildEntry(buildEntry) {
     (0, utils_js_1.assert)((0, utils_js_1.isObject)(buildEntry));
-    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(buildEntry, 'virtualFileExports', 'object'));
-    const { virtualFileExports } = buildEntry;
+    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(buildEntry, 'virtualFileExportsGlobalEntry', 'object'));
+    const { virtualFileExportsGlobalEntry } = buildEntry;
     (0, utils_js_1.assert)((0, utils_js_1.hasProp)(buildEntry, 'assetsManifest', 'object'));
     const { assetsManifest } = buildEntry;
     assertViteManifest(assetsManifest);
     (0, utils_js_1.assert)((0, utils_js_1.hasProp)(buildEntry, 'buildInfo', 'object'));
     const { buildInfo } = buildEntry;
     assertBuildInfo(buildInfo);
-    (0, utils_js_1.checkType)({ virtualFileExports, assetsManifest, buildInfo });
+    (0, utils_js_1.checkType)({ virtualFileExportsGlobalEntry, assetsManifest, buildInfo });
 }
 function assertBuildInfo(buildInfo) {
     (0, utils_js_1.assert)((0, utils_js_1.isObject)(buildInfo));
@@ -305,6 +322,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;
@@ -337,27 +355,57 @@ 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 virtualFileExportsGlobalEntry;
     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 {
+          virtualFileExportsGlobalEntry = await (viteDevServer.environments.ssr as RunnableDevEnvironment).runner.import(
+            'virtual:vike:global-entry:server',
+          )
+        } catch (err_) {
+          hasError = true
+          err = err_
+        }
+        */
+        // Vite 5
+        try {
+            virtualFileExportsGlobalEntry = await viteDevServer.ssrLoadModule(virtualFileId_js_1.virtualFileIdGlobalEntryServer);
+        }
+        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:global-entry:server')
+               ```
+            */
+            virtualFileExportsGlobalEntry = await __VIKE__DYNAMIC_IMPORT('virtual:vike:global-entry:server');
+        }
+        catch (err_) {
+            hasError = true;
+            err = err_;
+        }
     }
     if (isOutdated())
         return { success: false };
     if (hasError)
         return onError(err);
-    virtualFileExports = virtualFileExports.default || virtualFileExports;
+    virtualFileExportsGlobalEntry = virtualFileExportsGlobalEntry.default || virtualFileExportsGlobalEntry;
     if ((0, getVikeConfigError_js_1.getVikeConfigErrorBuild)()) {
         return { success: false };
     }
     try {
-        await setGlobalContext(virtualFileExports);
+        await createGlobalContext(virtualFileExportsGlobalEntry);
     }
     catch (err_) {
         hasError = true;
@@ -369,26 +417,26 @@ async function updateUserFiles() {
         return onError(err);
     return onSuccess();
 }
-async function setGlobalContext(virtualFileExports) {
-    debug('setGlobalContext()');
+async function createGlobalContext(virtualFileExportsGlobalEntry) {
+    debug('createGlobalContext()');
     (0, utils_js_1.assert)(!(0, getVikeConfigError_js_1.getVikeConfigErrorBuild)());
-    const globalContext = await (0, createGlobalContextShared_js_1.createGlobalContextShared)(virtualFileExports, globalObject, addGlobalContextAsync, addGlobalContextSync);
+    const globalContext = await (0, createGlobalContextShared_js_1.createGlobalContextShared)(virtualFileExportsGlobalEntry, 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 addGlobalContextAsync(globalContext) {
-    debug('addGlobalContextAsync()');
+async function addGlobalContextTmp(globalContext) {
+    debug('addGlobalContextTmp()');
     const { pageRoutes, onBeforeRouteHook } = await (0, loadPageRoutes_js_1.loadPageRoutes)(globalContext._pageFilesAll, globalContext._pageConfigs, globalContext._pageConfigGlobal, globalContext._allPageIds);
     return addGlobalContextCommon(globalContext, pageRoutes, onBeforeRouteHook);
 }
-function addGlobalContextSync(globalContext) {
-    debug('addGlobalContextSync()');
+function addGlobalContext(globalContext) {
+    debug('addGlobalContext()');
     const { pageRoutes, onBeforeRouteHook } = (0, loadPageRoutes_js_1.loadPageRoutesSync)(globalContext._pageFilesAll, globalContext._pageConfigs, globalContext._pageConfigGlobal, globalContext._allPageIds);
     return addGlobalContextCommon(globalContext, pageRoutes, onBeforeRouteHook);
 }
@@ -398,23 +446,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 {
@@ -425,11 +468,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) {
@@ -449,6 +490,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']);
@@ -457,6 +519,7 @@ function getInitialGlobalObject() {
     debug('getInitialGlobalObject()');
     const { promise: viteDevServerPromise, resolve: viteDevServerPromiseResolve } = (0, utils_js_1.genPromise)();
     return {
+        isProduction: isNonRunnableDev() ? false : undefined,
         viteDevServerPromise,
         viteDevServerPromiseResolve,
     };
@@ -467,3 +530,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/getHtmlTags.js

@@ -187,7 +187,7 @@ function mergeScriptEntries(pageAssets, viteDevScript) {
     return scriptEntry;
 }
 function getPageContextJsonScriptTag(pageContext) {
-    const pageContextClientSerialized = (0, sanitizeJson_js_1.sanitizeJson)((0, serializeContext_js_1.getPageContextClientSerialized)(pageContext));
+    const pageContextClientSerialized = (0, sanitizeJson_js_1.sanitizeJson)((0, serializeContext_js_1.getPageContextClientSerialized)(pageContext, true));
     const htmlTag = `<script id="${htmlElementIds_js_1.htmlElementId_pageContext}" type="application/json">${pageContextClientSerialized}</script>`;
     // Used by contra.com https://github.com/gajus
     // @ts-expect-error
@@ -195,7 +195,7 @@ function getPageContextJsonScriptTag(pageContext) {
     return htmlTag;
 }
 function getGlobalContextJsonScriptTag(pageContext) {
-    const globalContextClientSerialized = (0, sanitizeJson_js_1.sanitizeJson)((0, serializeContext_js_1.getGlobalContextClientSerialized)(pageContext));
+    const globalContextClientSerialized = (0, sanitizeJson_js_1.sanitizeJson)((0, serializeContext_js_1.getGlobalContextClientSerialized)(pageContext, true));
     const htmlTag = `<script id="${htmlElementIds_js_1.htmlElementId_globalContext}" type="application/json">${globalContextClientSerialized}</script>`;
     return htmlTag;
 }

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}`);