vike 0.4.236-commit-85d361d → 0.4.236-commit-64431e7

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

@@ -27,12 +27,12 @@ function createGetGlobalContextClient(virtualFileExports, isClientRouting, addGl
             return globalObject.globalContext;
         }
         // Create
-        const globalContext = await (0, createGlobalContextShared_js_1.createGlobalContextShared)(virtualFileExports, globalObject, async (globalContext) => {
+        const globalContext = await (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,
             };

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

@@ -155,6 +155,9 @@ function setGlobalContext_isPrerendering() {
     setIsProduction(true);
 }
 function setGlobalContext_isProduction(isProduction, tolerateContraditction = false) {
+    // TODO/now: try to remove globalObject.isProduction ?
+    // TODO/now: `rename tolerateContraditction tolerateContradiction`
+    tolerateContraditction = true;
     if (debug.isActivated)
         debug('setGlobalContext_isProduction()', { isProduction, tolerateContraditction });
     if (globalObject.isProduction === undefined) {
@@ -205,7 +208,12 @@ 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 {
+            await updateUserFiles();
+        }
         (0, utils_js_1.assert)(globalObject.waitForUserFilesUpdate);
         await globalObject.waitForUserFilesUpdate;
     }
@@ -339,16 +347,27 @@ 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) {
+        try {
+            virtualFileExports = await viteDevServer.ssrLoadModule(virtualFileEntry_js_1.virtualFileIdEntryServer);
+        }
+        catch (err_) {
+            hasError = true;
+            err = err_;
+        }
     }
-    catch (err_) {
-        hasError = true;
-        err = err_;
+    else {
+        try {
+            // We don't directly use import() to workaround what seems to be a Vite HMR bug: using import() breaks the HMR of normal non-worker apps.
+            virtualFileExports = await __VIKE__DYNAMIC_IMPORT('virtual:vike:entry:server');
+        }
+        catch (err_) {
+            hasError = true;
+            err = err_;
+        }
     }
     if (isOutdated())
         return { success: false };
@@ -374,7 +393,7 @@ async function updateUserFiles() {
 async function setGlobalContext(virtualFileExports) {
     debug('setGlobalContext()');
     (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)(virtualFileExports, globalObject, addGlobalContext, addGlobalContextTmp, addGlobalContextAsync);
     (0, assertV1Design_js_1.assertV1Design)(
     // pageConfigs is PageConfigRuntime[] but assertV1Design() requires PageConfigBuildTime[]
     globalContext._pageConfigs.length > 0, globalContext._pageFilesAll);
@@ -384,13 +403,13 @@ async function setGlobalContext(virtualFileExports) {
     // Never actually used, only used for TypeScript `ReturnType<typeof setGlobalContext>`
     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);
 }
@@ -400,23 +419,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 +441,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,14 +463,45 @@ function addGlobalContextCommon(globalContext, pageRoutes, onBeforeRouteHook) {
         }
     }
 }
+async function addGlobalContextAsync(globalContext) {
+    debug('addGlobalContextAsync()');
+    let { viteConfigRuntime, buildInfo } = globalObject;
+    if (!viteConfigRuntime) {
+        if (buildInfo) {
+            viteConfigRuntime = buildInfo.viteConfigRuntime;
+        }
+        else {
+            if (!isProcessSharedWithVite()) {
+                if (!globalObject.isProduction) {
+                    const rpc = (0, utils_js_1.getViteRPC)();
+                    viteConfigRuntime = await rpc.getViteConfigRuntimeRPC();
+                }
+                else {
+                    (0, utils_js_1.assert)(false); // production => globalObject.buildInfo should be set
+                }
+            }
+            else {
+                (0, utils_js_1.assert)(false); // process shared with Vite => globalObject.viteConfigRuntime should be set
+            }
+        }
+    }
+    (0, utils_js_1.assert)(viteConfigRuntime);
+    return {
+        viteConfigRuntime,
+        ...resolveBaseRuntime(viteConfigRuntime, globalContext.config),
+    };
+}
 function clearGlobalContext() {
     debug('clearGlobalContext()');
     (0, utils_js_1.objectReplace)(globalObject, getInitialGlobalObject(), ['buildEntryPrevious']);
 }
 function getInitialGlobalObject() {
-    debug('getInitialGlobalObject()');
+    const isProduction = getIsProductionStatic();
+    if (debug.isActivated)
+        debug('getInitialGlobalObject()', { isProduction });
     const { promise: viteDevServerPromise, resolve: viteDevServerPromiseResolve } = (0, utils_js_1.genPromise)();
     return {
+        isProduction,
         viteDevServerPromise,
         viteDevServerPromiseResolve,
     };
@@ -469,3 +512,22 @@ function resolveBaseRuntime(viteConfigRuntime, config) {
     const baseAssetsUnresolved = config.baseAssets ?? null;
     return (0, resolveBase_js_1.resolveBase)(baseViteOriginal, baseServerUnresolved, baseAssetsUnresolved);
 }
+function getIsProductionStatic() {
+    // TODO/now add @ts-ignore comments
+    // @ts-ignore
+    if (!({}))
+        return undefined;
+    // @ts-ignore
+    const PROD = ({}).PROD;
+    return PROD;
+}
+function isProcessSharedWithVite() {
+    const ret = globalThis.__VIKE__IS_PROCESS_SHARED_WITH_VITE;
+    if (globalObject.isProcessSharedWithVite !== undefined) {
+        (0, utils_js_1.assert)(globalObject.isProcessSharedWithVite === ret);
+    }
+    else {
+        globalObject.isProcessSharedWithVite = ret;
+    }
+    return ret;
+}

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

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getViteDevScript = getViteDevScript;
+const getViteRPC_js_1 = require("../../../../utils/getViteRPC.js");
 const utils_js_1 = require("../../utils.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const reachOutCTA = 'Create a new GitHub issue to discuss a solution.';
@@ -16,7 +17,13 @@ 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);
+    if (viteDevServer) {
+        fakeHtml = await viteDevServer.transformIndexHtml('/', fakeHtml);
+    }
+    else {
+        const rpc = (0, getViteRPC_js_1.getViteRPC)();
+        fakeHtml = await rpc.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

@@ -16,18 +16,11 @@ async function getPageAssets(pageContext, clientDependencies, clientEntries) {
     const globalContext = pageContext._globalContext;
     const { _isProduction: isProduction } = globalContext;
     const isDev = !isProduction;
-    let assetUrls;
-    let clientEntriesSrc;
-    if (isDev) {
-        const { _viteDevServer: viteDevServer } = globalContext;
-        clientEntriesSrc = clientEntries.map((clientEntry) => globalObject.resolveClientEntriesDev(clientEntry, viteDevServer));
-        assetUrls = await (0, retrieveAssetsDev_js_1.retrieveAssetsDev)(clientDependencies, viteDevServer);
-    }
-    else {
-        const { assetsManifest } = globalContext;
-        clientEntriesSrc = clientEntries.map((clientEntry) => resolveClientEntriesProd(clientEntry, assetsManifest));
-        assetUrls = (0, retrieveAssetsProd_js_1.retrieveAssetsProd)(clientDependencies, assetsManifest, resolveIncludeAssetsImportedByServer(pageContext._globalContext.config));
-    }
+    const { assetUrls, clientEntriesSrc } = isDev
+        ? !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) => {
         const { mediaType = null, assetType = null } = (0, inferMediaType_js_1.inferMediaType)(src) || {};
@@ -61,6 +54,16 @@ async function getPageAssets(pageContext, clientDependencies, clientEntries) {
     await (0, sortPageAssetsForEarlyHintsHeader_js_1.sortPageAssetsForEarlyHintsHeader)(pageAssets, isProduction);
     return pageAssets;
 }
+async function retrievePageAssetsDev(viteDevServer, clientDependencies, clientEntries) {
+    const clientEntriesSrc = clientEntries.map((clientEntry) => globalObject.resolveClientEntriesDev(clientEntry, viteDevServer));
+    const assetUrls = await (0, retrieveAssetsDev_js_1.retrieveAssetsDev)(clientDependencies, viteDevServer);
+    return { clientEntriesSrc, assetUrls };
+}
+function retrievePageAssetsProd(assetsManifest, clientDependencies, clientEntries, includeAssetsImportedByServer) {
+    const clientEntriesSrc = clientEntries.map((clientEntry) => resolveClientEntriesProd(clientEntry, assetsManifest));
+    const assetUrls = (0, retrieveAssetsProd_js_1.retrieveAssetsProd)(clientDependencies, assetsManifest, resolveIncludeAssetsImportedByServer(includeAssetsImportedByServer));
+    return { clientEntriesSrc, assetUrls };
+}
 function resolveClientEntriesProd(clientEntry, assetsManifest) {
     const { manifestEntry } = (0, getManifestEntry_js_1.getManifestEntry)(clientEntry, assetsManifest);
     (0, utils_js_1.assert)(manifestEntry.isEntry || manifestEntry.isDynamicEntry || clientEntry.endsWith('.css'), { clientEntry });

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

@@ -76,3 +76,4 @@ __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);

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 pluginViteRPC_js_1 = require("./plugins/pluginViteRPC.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, pluginViteRPC_js_1.pluginViteRPC)(),
     ];
     Object.assign(plugins, { _vikeVitePluginOptions: vikeVitePluginOptions });
     return plugins;

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

@@ -300,8 +300,8 @@ async function handleAssetsManifest_getBuildConfig(config) {
     };
 }
 async function handleAssetsManifest(config, viteEnv, options, bundle) {
-    const isSsREnv = (0, isViteServerBuild_js_1.isViteServerBuild_onlySsrEnv)(config, viteEnv);
-    if (isSsREnv) {
+    const isSsrEnv = (0, isViteServerBuild_js_1.isViteServerBuild_onlySsrEnv)(config, viteEnv);
+    if (isSsrEnv) {
         (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');
@@ -315,7 +315,7 @@ async function handleAssetsManifest(config, viteEnv, options, bundle) {
         // - Also in some other server builds such as dist/vercel/ from vike-vercel
         // - Don't replace it in dist/rsc/ from vike-react-rsc since __VITE_ASSETS_MANIFEST__ doesn't exist there
         const noop = await (0, pluginBuildEntry_js_1.set_macro_ASSETS_MANIFEST)(assetsJsonFilePath, bundle, outDir);
-        if (isSsREnv)
+        if (isSsrEnv)
             (0, utils_js_1.assert)(!noop); // dist/server should always contain __VITE_ASSETS_MANIFEST__
     }
 }

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

@@ -16,7 +16,8 @@ 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';
+// TODO/now: stop setting `manifest` altogether and use the resolved value instead? So that other tools can easily read the manifest (e.g. @cloudflare/plugin-vite reads the manifest).
+const manifestTempFile = '.vite/manifest.json';
 exports.manifestTempFile = manifestTempFile;
 function pluginBuildConfig() {
     let config;

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

@@ -18,6 +18,8 @@ function pluginDistFileNames() {
         apply: 'build',
         enforce: 'post',
         configResolved(config) {
+            // TODO/now remove
+            // if (true as boolean) return
             const rollupOutputs = getRollupOutputs(config);
             // We need to support multiple outputs: @vite/plugin-legacy adds an output, see https://github.com/vikejs/vike/issues/477#issuecomment-1406434802
             rollupOutputs.forEach((rollupOutput) => {
@@ -106,6 +108,7 @@ function getIdHash(id) {
     return node_crypto_1.default.createHash('md5').update(id).digest('hex').slice(0, 8);
 }
 function getAssetFileName(assetInfo, config) {
+    const userRootDir = config.root;
     const assetsDir = (0, getAssetsDir_js_1.getAssetsDir)(config);
     const dir = assetsDir + '/static';
     let { name } = assetInfo;
@@ -123,11 +126,11 @@ function getAssetFileName(assetInfo, config) {
         // Vite 3
         name?.endsWith('?extractAssets&lang.css')) {
         name = name.split('.').slice(0, -2).join('.');
-        name = clean(name);
+        name = clean(name, userRootDir);
         return `${dir}/${name}.[hash][extname]`;
     }
     name = name.split('.').slice(0, -1).join('.');
-    name = clean(name);
+    name = clean(name, userRootDir);
     return `${dir}/${name}.[hash][extname]`;
 }
 function getChunkFileName(_chunkInfo, config) {
@@ -140,11 +143,12 @@ function getChunkFileName(_chunkInfo, config) {
     return name;
 }
 function getEntryFileName(chunkInfo, config, isEntry) {
+    const userRootDir = config.root;
     const assetsDir = (0, getAssetsDir_js_1.getAssetsDir)(config);
     const isForClientSide = !config.build.ssr;
     let { name } = chunkInfo;
     (0, utils_js_1.assertPosixPath)(name);
-    name = clean(name, true, 
+    name = clean(name, userRootDir, true, 
     // Not needed for client-side because dist/ filenames contain `.[hash].js`
     !isForClientSide);
     if (isForClientSide) {
@@ -154,9 +158,14 @@ function getEntryFileName(chunkInfo, config, isEntry) {
         return `${name}.${isEntry ? 'mjs' : 'js'}`;
     }
 }
-function removePathSeparators(name) {
+function removePathSeparators(name, userRootDir) {
     (0, utils_js_1.assertPosixPath)(name);
-    (0, utils_js_1.assert)(!name.startsWith('/'));
+    if (name.startsWith(userRootDir)) {
+        name = name.slice(userRootDir.length);
+        if (name.startsWith('/'))
+            name = name.slice(1);
+    }
+    (0, utils_js_1.assert)(!name.startsWith('/'), { name });
     const entryDir = 'entries/';
     const hasEntryDir = name.startsWith(entryDir);
     if (hasEntryDir) {
@@ -169,14 +178,14 @@ function removePathSeparators(name) {
     }
     return name;
 }
-function clean(name, removePathSep, fixGlob) {
+function clean(name, userRootDir, removePathSep, fixGlob) {
     name = fixExtractAssetsQuery(name);
     if (fixGlob) {
         name = workaroundGlob(name);
     }
     name = replaceNonLatinCharacters(name);
     if (removePathSep) {
-        name = removePathSeparators(name);
+        name = removePathSeparators(name, userRootDir);
     }
     name = removeLeadingUnderscoreInFilename(name);
     name = removeUnderscoreDoublets(name);

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/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/pluginReplaceConstants.js

@@ -26,7 +26,7 @@ function pluginReplaceConstants() {
             (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';
             (0, utils_js_1.assert)(isBuild);

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

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pluginViteRPC = pluginViteRPC;
+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");
+(0, utils_js_1.assertIsNotProductionRuntime)();
+function getViteRpcFunctions(viteDevServer) {
+    return {
+        async transformIndexHtmlRPC(html) {
+            return await viteDevServer.transformIndexHtml('/', html);
+        },
+        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() {
+            const viteConfigRuntime = (0, getViteConfigRuntime_js_1.getViteConfigRuntime)(viteDevServer.config);
+            return viteConfigRuntime;
+        },
+    };
+}
+function pluginViteRPC() {
+    const runtimeFileWithDynamicImport = (0, utils_js_1.requireResolveVikeDistFile)('dist/esm/node/runtime/globalContext.js');
+    return {
+        name: 'vike:pluginViteRPC',
+        configureServer(viteDevServer) {
+            (0, utils_js_1.createViteRPC)(viteDevServer, getViteRpcFunctions);
+        },
+        transform(code, id) {
+            if (id !== runtimeFileWithDynamicImport)
+                return;
+            const envName = this.environment?.name;
+            if (!envName || ['client', 'ssr'].includes(envName))
+                return;
+            // TODO/now use magic-string
+            return code.replaceAll('__VIKE__DYNAMIC_IMPORT', 'import');
+        },
+    };
+}

package/dist/cjs/node/vite/shared/applyRegExWithMagicString.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.applyRegExpWithMagicString = applyRegExpWithMagicString;
+// TODO/now: replace with .replaceAll() ?
 function applyRegExpWithMagicString(magicString, regExp, replacement) {
     const envStatementRegEx = typeof regExp === 'string' ? new RegExp(regExp, 'g') : regExp;
     let match;

package/dist/cjs/shared/createGlobalContextShared.js

@@ -10,25 +10,33 @@ const prepareGlobalContextForPublicUsage_js_1 = require("./prepareGlobalContextF
 const getHook_js_1 = require("./hooks/getHook.js");
 const getGlobalContextSyncErrMsg = "The global context isn't set yet, call getGlobalContextSync() later or use getGlobalContext() instead.";
 exports.getGlobalContextSyncErrMsg = getGlobalContextSyncErrMsg;
-async function createGlobalContextShared(virtualFileExports, globalObject, addGlobalContextAsync, addGlobalContextSync) {
+async function createGlobalContextShared(virtualFileExports, globalObject, addGlobalContext, 
+// TO-DO/next-major-release: we'll be able to remove addGlobalContextTmp after loadPageRoutes() is sync (it will be sync after we remove the old design)
+addGlobalContextTmp, addGlobalContextAsync) {
     const globalContext = createGlobalContextBase(virtualFileExports);
     let isNewGlobalContext;
     if (!globalObject.globalContext) {
+        // We set globalObject.globalContext early and before any async operations, so that getGlobalContextSync() can be used early.
+        // - Required by vike-vercel
         globalObject.globalContext = globalContext;
         isNewGlobalContext = false;
     }
     else {
         isNewGlobalContext = true;
     }
-    if (addGlobalContextSync &&
+    if (addGlobalContext &&
         // TODO/next-major-release: remove
         globalContext._pageConfigs.length > 0) {
-        const globalContextAddendum = addGlobalContextSync?.(globalContext);
-        (0, utils_js_1.objectAssign)(globalContext, globalContextAddendum);
+        const globalContextAdded = addGlobalContext?.(globalContext);
+        (0, utils_js_1.objectAssign)(globalContext, globalContextAdded);
     }
     else {
-        const globalContextAddendum = await addGlobalContextAsync?.(globalContext);
-        (0, utils_js_1.objectAssign)(globalContext, globalContextAddendum);
+        const globalContextAdded = await addGlobalContextTmp?.(globalContext);
+        (0, utils_js_1.objectAssign)(globalContext, globalContextAdded);
+    }
+    {
+        const globalContextAddedAsync = await addGlobalContextAsync?.(globalContext);
+        (0, utils_js_1.objectAssign)(globalContext, globalContextAddedAsync);
     }
     const onCreateGlobalContextHooks = (0, getHook_js_1.getHookFromPageConfigGlobalCumulative)(globalContext._pageConfigGlobal, 'onCreateGlobalContext');
     let hooksCalled = false;

package/dist/cjs/shared/getProxyForPublicUsage.js

@@ -43,8 +43,8 @@ function onInternalProp(propStr, objName) {
     // - We must skip it in the client-side because of the reactivity mechanism of UI frameworks like Solid.
     // - TO-DO/eventually: use import.meta.CLIENT instead of isBrowser()
     //   - Where import.meta.CLIENT is defined by Vike
-    //   - Using import.meta.env.CLIENT (note `.env.`) doesn't seem possible: https://github.com/brillout/playground_node_import.meta.env
-    //     - If Rolldown Vite + Rolldowns always transpiles node_modules/ then we can simply use import.meta.env.SSR
+    //   - Using ({}).CLIENT (note `.env.`) doesn't seem possible: https://github.com/brillout/playground_node_({})
+    //     - If Rolldown Vite + Rolldowns always transpiles node_modules/ then we can simply use ({}).SSR
     if ((0, utils_js_1.isBrowser)())
         return;
     // TO-DO/soon/proxy: remove this and only warn on built-in access instead

package/dist/cjs/utils/PROJECT_VERSION.js

@@ -2,4 +2,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PROJECT_VERSION = void 0;
 // Automatically updated by @brillout/release-me
-exports.PROJECT_VERSION = '0.4.236-commit-85d361d';
+exports.PROJECT_VERSION = '0.4.236-commit-64431e7';

package/dist/cjs/utils/assertSetup.js

@@ -29,6 +29,9 @@ function assertIsNotProductionRuntime() {
     setup.shouldNotBeProduction = true;
 }
 function onSetupRuntime() {
+    // TODO/now
+    if (true)
+        return;
     if (debug.isActivated)
         debug('assertSetup()', new Error().stack);
     if (isTest())

package/dist/cjs/utils/debug.js

@@ -35,6 +35,7 @@ const flags = [
     'vike:setup',
     'vike:stream',
     'vike:virtualFiles',
+    'vike:vite-rpc',
 ];
 const flagsSkipWildcard = ['vike:log'];
 const flagRegex = /\bvike:[a-zA-Z-]+/g;