vike 0.4.236-commit-08fbc10 → 0.4.236-commit-79f1ef0

package/dist/esm/node/runtime/renderPage.d.ts

@@ -46,24 +46,12 @@ declare function getPageContextBegin(pageContextInit: PageContextInit, globalCon
         pages: {
             [k: string]: import("../../shared/page-configs/resolveVikeConfigPublic.js").VikeConfigPublicPageEager;
         };
-    } & ({
+    } & (({
         _isProduction: false;
         _isPrerendering: false;
         assetsManifest: null;
-        _viteDevServer: import("vite").ViteDevServer;
-        viteConfig: import("vite").ResolvedConfig;
-        viteConfigRuntime: {
-            root: string;
-            build: {
-                outDir: string;
-            };
-            _baseViteOriginal: string;
-            vitePluginServerEntry: {
-                inject: boolean | undefined;
-            };
-        };
-        baseServer: string;
-        baseAssets: string;
+        _viteDevServer: import("vite").ViteDevServer | undefined;
+        viteConfig: import("vite").ResolvedConfig | undefined;
         isClientSide: false;
         _pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
         _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
@@ -73,19 +61,7 @@ declare function getPageContextBegin(pageContextInit: PageContextInit, globalCon
         _isProduction: true;
         assetsManifest: import("../../types/ViteManifest.js").ViteManifest;
         _viteDevServer: null;
-        viteConfigRuntime: {
-            root: string;
-            build: {
-                outDir: string;
-            };
-            _baseViteOriginal: string;
-            vitePluginServerEntry: {
-                inject: boolean | undefined;
-            };
-        };
         _usesClientRouter: boolean;
-        baseServer: string;
-        baseAssets: string;
         isClientSide: false;
         _pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
         _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
@@ -95,6 +71,13 @@ declare function getPageContextBegin(pageContextInit: PageContextInit, globalCon
         _isProduction: true;
         assetsManifest: import("../../types/ViteManifest.js").ViteManifest;
         _viteDevServer: null;
+        _usesClientRouter: boolean;
+        isClientSide: false;
+        _pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
+        _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
+    }) & {
+        baseServer: string;
+        baseAssets: string;
         viteConfigRuntime: {
             root: string;
             build: {
@@ -105,12 +88,6 @@ declare function getPageContextBegin(pageContextInit: PageContextInit, globalCon
                 inject: boolean | undefined;
             };
         };
-        _usesClientRouter: boolean;
-        baseServer: string;
-        baseAssets: string;
-        isClientSide: false;
-        _pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
-        _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
     });
     _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
     _baseServer: string;

package/dist/esm/node/runtime/utils.d.ts

@@ -57,3 +57,6 @@ export * from '../../utils/PROJECT_VERSION.js';
 export * from '../../utils/genPromise.js';
 export * from '../../utils/augmentType.js';
 export * from '../../utils/changeEnumerable.js';
+export * from '../../utils/getViteRPC.js';
+export * from '../../utils/isRunnableDevEnvironment.js';
+export * from '../../utils/assertIsNotBrowser.js';

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

@@ -61,3 +61,6 @@ export * from '../../utils/PROJECT_VERSION.js';
 export * from '../../utils/genPromise.js';
 export * from '../../utils/augmentType.js';
 export * from '../../utils/changeEnumerable.js';
+export * from '../../utils/getViteRPC.js';
+export * from '../../utils/isRunnableDevEnvironment.js';
+export * from '../../utils/assertIsNotBrowser.js';

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

@@ -22,6 +22,7 @@ import { resolveClientEntriesDev } from './shared/resolveClientEntriesDev.js';
 import { pluginWorkaroundCssModuleHmr } from './plugins/pluginWorkaroundCssModuleHmr.js';
 import { pluginWorkaroundVite6HmrRegression } from './plugins/pluginWorkaroundVite6HmrRegression.js';
 import { pluginReplaceConstants } from './plugins/pluginReplaceConstants.js';
+import { pluginNonRunnableDev } from './plugins/pluginNonRunnableDev.js';
 // We don't call this in ./onLoad.ts to avoid a cyclic dependency with utils.ts
 setResolveClientEntriesDev(resolveClientEntriesDev);
 // Return `PluginInterop` instead of `Plugin` to avoid type mismatch upon different Vite versions
@@ -41,6 +42,7 @@ function plugin(vikeVitePluginOptions = {}) {
         pluginWorkaroundCssModuleHmr(),
         pluginWorkaroundVite6HmrRegression(),
         pluginReplaceConstants(),
+        pluginNonRunnableDev(),
     ];
     Object.assign(plugins, { _vikeVitePluginOptions: vikeVitePluginOptions });
     return plugins;

package/dist/esm/node/vite/plugins/pluginBuild/handleAssetsManifest.d.ts

@@ -11,7 +11,7 @@ declare function handleAssetsManifest_assertUsageCssTarget(config: ResolvedConfi
 declare function handleAssetsManifest_getBuildConfig(config: UserConfig): Promise<{
     readonly ssrEmitAssets: true | undefined;
     readonly cssMinify: "esbuild" | undefined;
-    readonly manifest: "_temp_manifest.json";
+    readonly manifest: true;
     readonly copyPublicDir: boolean | undefined;
 }>;
 declare function handleAssetsManifest(config: ResolvedConfig, viteEnv: Environment | undefined, options: {

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

@@ -9,13 +9,13 @@ import path from 'node:path';
 import { existsSync } from 'node:fs';
 import { assert, assertIsSingleModuleInstance, assertWarning, isEqualStringList, isObject, pLimit, unique, } from '../../utils.js';
 import { isVirtualFileIdPageConfigLazy } from '../../../shared/virtualFiles/virtualFilePageConfigLazy.js';
-import { manifestTempFile } from './pluginBuildConfig.js';
 import { getAssetsDir } from '../../shared/getAssetsDir.js';
 import pc from '@brillout/picocolors';
 import { getVikeConfigInternal, isV1Design } from '../../shared/resolveVikeConfigInternal.js';
 import { getOutDirs } from '../../shared/getOutDirs.js';
 import { isViteServerBuild_onlySsrEnv, isViteServerBuild } from '../../shared/isViteServerBuild.js';
 import { set_macro_ASSETS_MANIFEST } from './pluginBuildEntry.js';
+import { getManifestFilePathRelative } from '../../shared/getManifestFilePathRelative.js';
 assertIsSingleModuleInstance('build/handleAssetsManifest.ts');
 let assetsJsonFilePath;
 // true  => use workaround config.build.ssrEmitAssets
@@ -26,9 +26,8 @@ function handleAssetsManifest_isFixEnabled(config) {
 }
 /** https://github.com/vikejs/vike/issues/1339 */
 async function fixServerAssets(config) {
-    const outDirs = 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 };
@@ -265,8 +264,8 @@ function removeEmptyDirectories(dirPath) {
         fs_sync.rmdirSync(dirPath);
     }
 }
-async function readManifestFile(outDir) {
-    const manifestFilePath = path.posix.join(outDir, manifestTempFile);
+async function readManifestFile(config, client) {
+    const manifestFilePath = getManifestFilePath(config, client);
     const manifestFileContent = await fs.readFile(manifestFilePath, 'utf-8');
     assert(manifestFileContent);
     const manifest = JSON.parse(manifestFileContent);
@@ -287,7 +286,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: manifestTempFile,
+        manifest: true,
         copyPublicDir: vikeConfig.config.vite6BuilderApp
             ? // Already set by vike:build:pluginBuildApp
                 undefined
@@ -300,7 +299,7 @@ async function handleAssetsManifest(config, viteEnv, options, bundle) {
         assert(!assetsJsonFilePath);
         const outDirs = getOutDirs(config, viteEnv);
         assetsJsonFilePath = path.posix.join(outDirs.outDirRoot, 'assets.json');
-        await writeAssetsManifestFile(outDirs, assetsJsonFilePath, config);
+        await writeAssetsManifestFile(assetsJsonFilePath, config);
     }
     if (isViteServerBuild(config, viteEnv)) {
         const outDir = options.dir;
@@ -314,10 +313,10 @@ async function handleAssetsManifest(config, viteEnv, options, bundle) {
             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 = path.posix.join(outDirs.outDirClient, manifestTempFile);
-    const serverManifestFilePath = path.posix.join(outDirs.outDirServer, manifestTempFile);
+    const clientManifestFilePath = getManifestFilePath(config, true);
+    const serverManifestFilePath = getManifestFilePath(config, false);
     if (!isFixEnabled) {
         await fs.copyFile(clientManifestFilePath, assetsJsonFilePath);
     }
@@ -328,3 +327,12 @@ async function writeAssetsManifestFile(outDirs, assetsJsonFilePath, config) {
     await fs.rm(clientManifestFilePath);
     await fs.rm(serverManifestFilePath);
 }
+function getManifestFilePath(config, client) {
+    const outDirs = getOutDirs(config);
+    const outDir = client ? outDirs.outDirClient : outDirs.outDirServer;
+    const env = client ? config.environments.client : config.environments.ssr;
+    assert(env);
+    const manifestFilePathRelative = getManifestFilePathRelative(env.build.manifest);
+    const manifestFilePath = path.posix.join(outDir, manifestFilePathRelative);
+    return manifestFilePath;
+}

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

@@ -6,12 +6,12 @@ import { isPrerenderAutoRunEnabled, wasPrerenderRun } from '../../../prerender/c
 import { isViteCliCall, getViteConfigFromCli } from '../../shared/isViteCliCall.js';
 import pc from '@brillout/picocolors';
 import { logErrorHint } from '../../../runtime/renderPage/logErrorHint.js';
-import { manifestTempFile } from './pluginBuildConfig.js';
 import { getVikeConfigInternal } from '../../shared/resolveVikeConfigInternal.js';
 import { isVikeCliOrApi } from '../../../api/context.js';
 import { handleAssetsManifest, handleAssetsManifest_assertUsageCssTarget } from './handleAssetsManifest.js';
 import { isViteClientBuild, isViteServerBuild_onlySsrEnv } from '../../shared/isViteServerBuild.js';
 import { runPrerender_forceExit, runPrerenderFromAutoRun } from '../../../prerender/runPrerenderEntry.js';
+import { getManifestFilePathRelative } from '../../shared/getManifestFilePathRelative.js';
 assertIsSingleModuleInstance('build/pluginAutoFullBuild.ts');
 let forceExit = false;
 function pluginAutoFullBuild() {
@@ -82,7 +82,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[manifestTempFile])
+    if (!bundle[getManifestFilePathRelative(config.build.manifest)])
         return;
     const configInline = getFullBuildInlineConfig(config);
     if (!isBuilderApp) {

package/dist/esm/node/vite/plugins/pluginBuild/pluginBuildConfig.d.ts

@@ -1,10 +1,8 @@
 export { pluginBuildConfig };
 export { assertRollupInput };
 export { analyzeClientEntries };
-export { manifestTempFile };
 import type { ResolvedConfig, Plugin } from 'vite';
 import type { PageConfigBuildTime } from '../../../../types/PageConfig.js';
-declare const manifestTempFile = "_temp_manifest.json";
 declare function pluginBuildConfig(): Plugin[];
 declare function analyzeClientEntries(pageConfigs: PageConfigBuildTime[], config: ResolvedConfig): {
     hasClientRouting: boolean;

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

@@ -1,7 +1,6 @@
 export { pluginBuildConfig };
 export { assertRollupInput };
 export { analyzeClientEntries };
-export { manifestTempFile };
 import { assert, addOnBeforeLogHook, removeFileExtension, unique, assertUsage, injectRollupInputs, normalizeRollupInput, onSetupBuild, assertIsImportPathNpmPackage, requireResolveVikeDistFile, } from '../../utils.js';
 import { getVikeConfigInternal } from '../../shared/resolveVikeConfigInternal.js';
 import { findPageFiles } from '../../shared/findPageFiles.js';
@@ -14,7 +13,6 @@ import { isViteServerBuild } from '../../shared/isViteServerBuild.js';
 import { resolveOutDir } from '../../shared/getOutDirs.js';
 import { handleAssetsManifest_assertUsageCssCodeSplit, handleAssetsManifest_getBuildConfig, } from './handleAssetsManifest.js';
 import { resolveIncludeAssetsImportedByServer } from '../../../runtime/renderPage/getPageAssets.js';
-const manifestTempFile = '_temp_manifest.json';
 function pluginBuildConfig() {
     let config;
     return [

package/dist/esm/node/vite/plugins/pluginCommon.d.ts

@@ -10,4 +10,7 @@ declare module 'vite' {
         _viteConfigFromUserEnhanced?: InlineConfig;
     }
 }
+declare global {
+    var __VIKE__IS_PROCESS_SHARED_WITH_VITE: undefined | true;
+}
 declare function pluginCommon(vikeVitePluginOptions: unknown): Plugin[];

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

@@ -11,6 +11,7 @@ import { getVikeConfigInternal, setVikeConfigContext } from '../shared/resolveVi
 import { assertViteRoot, getViteRoot, normalizeViteRoot } from '../../api/prepareViteApiCall.js';
 import { temp_disablePrerenderAutoRun } from '../../prerender/context.js';
 const pluginName = 'vike:pluginCommon';
+globalThis.__VIKE__IS_PROCESS_SHARED_WITH_VITE = true;
 function pluginCommon(vikeVitePluginOptions) {
     return [
         {

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

@@ -12,21 +12,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/esm/node/vite/plugins/pluginNonRunnableDev.d.ts

@@ -0,0 +1,26 @@
+export { pluginNonRunnableDev };
+import type { Plugin, ViteDevServer } from 'vite';
+import type { ClientDependency } from '../../../shared/getPageFiles/analyzePageClientSide/ClientDependency.js';
+export type ViteRPC = ReturnType<typeof getViteRpcFunctions>;
+declare function getViteRpcFunctions(viteDevServer: ViteDevServer): {
+    transformIndexHtmlRPC(html: string): Promise<string>;
+    retrievePageAssetsDevRPC(clientDependencies: ClientDependency[], clientEntries: string[]): Promise<{
+        clientEntriesSrc: string[];
+        assetUrls: string[];
+    }>;
+    getViteConfigRuntimeRPC(): Promise<{
+        root: string;
+        build: {
+            outDir: string;
+        };
+        _baseViteOriginal: string;
+        vitePluginServerEntry: {
+            inject: boolean | undefined;
+        };
+    }>;
+};
+declare global {
+    var __VIKE__DYNAMIC_IMPORT: (module: string) => Promise<Record<string, unknown>>;
+    var __VIKE__IS_NON_RUNNABLE_DEV: undefined | boolean;
+}
+declare function pluginNonRunnableDev(): Plugin;

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

@@ -0,0 +1,49 @@
+export { pluginNonRunnableDev };
+import { createViteRPC, assertIsNotProductionRuntime, requireResolveVikeDistFile, isRunnableDevEnvironment, } from '../utils.js';
+import { resolveClientEntriesDev } from '../shared/resolveClientEntriesDev.js';
+import { retrieveAssetsDev } from '../../runtime/renderPage/getPageAssets/retrieveAssetsDev.js';
+import { getViteConfigRuntime } from '../shared/getViteConfigRuntime.js';
+import { getMagicString } from '../shared/getMagicString.js';
+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) => resolveClientEntriesDev(clientEntry, viteDevServer));
+            const assetUrls = await retrieveAssetsDev(clientDependencies, viteDevServer);
+            return { clientEntriesSrc, assetUrls };
+        },
+        async getViteConfigRuntimeRPC() {
+            return getViteConfigRuntime(viteDevServer.config);
+        },
+    };
+}
+function pluginNonRunnableDev() {
+    const runtimeGlobalContextFilePath = requireResolveVikeDistFile('dist/esm/node/runtime/globalContext.js');
+    let config;
+    return {
+        name: 'vike:pluginNonRunnableDev',
+        configureServer(viteDevServer) {
+            createViteRPC(viteDevServer, getViteRpcFunctions);
+        },
+        configResolved(config_) {
+            config = config_;
+        },
+        transform(code, id) {
+            if (!config._isDev)
+                return;
+            if (id !== runtimeGlobalContextFilePath)
+                return;
+            const isNonRunnableDev = !isRunnableDevEnvironment(this.environment);
+            const { magicString, getMagicStringResult } = getMagicString(code, id);
+            if (isNonRunnableDev) {
+                magicString.replaceAll('__VIKE__DYNAMIC_IMPORT', 'import');
+            }
+            magicString.replaceAll('__VIKE__IS_NON_RUNNABLE_DEV', JSON.stringify(isNonRunnableDev));
+            return getMagicStringResult();
+        },
+    };
+}

package/dist/esm/node/vite/plugins/pluginVirtualFiles/getVirtualFilePageConfigsEager.js

@@ -19,6 +19,10 @@ function getCode(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, isCl
     lines.push('export const pageConfigGlobalSerialized = {');
     lines.push(getCodePageConfigGlobalSerialized(pageConfigGlobal, isForClientSide, isClientRouting, isDev, importStatements, filesEnv));
     lines.push('};');
+    if (!isForClientSide && isDev) {
+        // https://vite.dev/guide/api-environment-frameworks.html
+        lines.push('if (import.meta.hot) import.meta.hot.accept();');
+    }
     const code = [...importStatements, ...lines].join('\n');
     debug(id, isForClientSide ? 'CLIENT-SIDE' : 'SERVER-SIDE', code);
     return code;

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

@@ -1,4 +1,5 @@
 export { 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/esm/node/vite/shared/getMagicString.d.ts

@@ -0,0 +1,9 @@
+export { getMagicString };
+import MagicString from 'magic-string';
+declare function getMagicString(code: string, id: string): {
+    magicString: MagicString;
+    getMagicStringResult: () => {
+        code: string;
+        map: import("magic-string").SourceMap;
+    };
+};

package/dist/esm/node/vite/shared/getMagicString.js

@@ -0,0 +1,13 @@
+export { getMagicString };
+import MagicString from 'magic-string';
+// TODO/now use everywhere
+function getMagicString(code, id) {
+    const magicString = new MagicString(code);
+    const getMagicStringResult = () => {
+        return {
+            code: magicString.toString(),
+            map: magicString.generateMap({ hires: true, source: id }),
+        };
+    };
+    return { magicString, getMagicStringResult };
+}

package/dist/esm/node/vite/shared/getManifestFilePathRelative.d.ts

@@ -0,0 +1,2 @@
+export { getManifestFilePathRelative };
+declare function getManifestFilePathRelative(manifestConfig: string | boolean): string;

package/dist/esm/node/vite/shared/getManifestFilePathRelative.js

@@ -0,0 +1,8 @@
+export { getManifestFilePathRelative };
+import { assert } from '../utils.js';
+function getManifestFilePathRelative(manifestConfig) {
+    assert(['string', 'boolean'].includes(typeof manifestConfig));
+    assert(manifestConfig !== false);
+    const manifestFileRelative = typeof manifestConfig === 'string' ? manifestConfig : '.vite/manifest.json';
+    return manifestFileRelative;
+}

package/dist/esm/shared/createGlobalContextShared.d.ts

@@ -9,10 +9,10 @@ import type { GlobalContextServerInternal } from '../node/runtime/globalContext.
 import type { GlobalContextClientInternal } from '../client/runtime-client-routing/globalContext.js';
 import { type Hook } from './hooks/getHook.js';
 declare const getGlobalContextSyncErrMsg = "The global context isn't set yet, call getGlobalContextSync() later or use getGlobalContext() instead.";
-declare function createGlobalContextShared<GlobalContextAdded extends Record<string, any>>(virtualFileExports: unknown, globalObject: {
+declare function createGlobalContextShared<GlobalContextAdded extends Record<string, any>, GlobalContextAddedAsync extends Record<string, any>>(virtualFileExports: unknown, globalObject: {
     globalContext?: Record<string, unknown>;
     onCreateGlobalContextHooks?: Hook[];
-}, addGlobalContext?: (globalContext: GlobalContextBase) => GlobalContextAdded, addGlobalContextTmp?: (globalContext: GlobalContextBase) => Promise<GlobalContextAdded>): Promise<{
+}, addGlobalContext?: (globalContext: GlobalContextBase) => GlobalContextAdded, addGlobalContextTmp?: (globalContext: GlobalContextBase) => Promise<GlobalContextAdded>, addGlobalContextAsync?: (globalContext: GlobalContextBase) => Promise<GlobalContextAddedAsync>): Promise<{
     /**
      * Useful for distinguishing `globalContext` from other objects and narrowing down TypeScript unions.
      *
@@ -35,7 +35,7 @@ declare function createGlobalContextShared<GlobalContextAdded extends Record<str
     pages: {
         [k: string]: import("./page-configs/resolveVikeConfigPublic.js").VikeConfigPublicPageEager;
     };
-} & GlobalContextAdded>;
+} & GlobalContextAdded & GlobalContextAddedAsync>;
 type GlobalContextBasePublic = Pick<GlobalContextBase, 'config' | 'pages' | 'isGlobalContext'>;
 type GlobalContextBase = ReturnType<typeof createGlobalContextBase>;
 declare function createGlobalContextBase(virtualFileExports: unknown): {

package/dist/esm/shared/createGlobalContextShared.js

@@ -9,7 +9,7 @@ import { getHookFromPageConfigGlobalCumulative } from './hooks/getHook.js';
 const getGlobalContextSyncErrMsg = "The global context isn't set yet, call getGlobalContextSync() later or use getGlobalContext() instead.";
 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) {
+addGlobalContextTmp, addGlobalContextAsync) {
     const globalContext = createGlobalContextBase(virtualFileExports);
     let isNewGlobalContext;
     if (!globalObject.globalContext) {
@@ -31,6 +31,10 @@ addGlobalContextTmp) {
         const globalContextAdded = await addGlobalContextTmp?.(globalContext);
         objectAssign(globalContext, globalContextAdded);
     }
+    {
+        const globalContextAddedAsync = await addGlobalContextAsync?.(globalContext);
+        objectAssign(globalContext, globalContextAddedAsync);
+    }
     const onCreateGlobalContextHooks = getHookFromPageConfigGlobalCumulative(globalContext._pageConfigGlobal, 'onCreateGlobalContext');
     let hooksCalled = false;
     if (!hooksAreEqual(globalObject.onCreateGlobalContextHooks ?? [], onCreateGlobalContextHooks)) {

package/dist/esm/utils/PROJECT_VERSION.d.ts

@@ -1 +1 @@
-export declare const PROJECT_VERSION: "0.4.236-commit-08fbc10";
+export declare const PROJECT_VERSION: "0.4.236-commit-79f1ef0";

package/dist/esm/utils/PROJECT_VERSION.js

@@ -1,2 +1,2 @@
 // Automatically updated by @brillout/release-me
-export const PROJECT_VERSION = '0.4.236-commit-08fbc10';
+export const PROJECT_VERSION = '0.4.236-commit-79f1ef0';

package/dist/esm/utils/assertSetup.js

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

package/dist/esm/utils/debug.d.ts

@@ -1,7 +1,7 @@
 export { createDebugger };
 export { isDebugActivated };
 export type { Debug };
-declare const flags: readonly ["vike:crawl", "vike:error", "vike:esbuild-resolve", "vike:pluginExtractAssets", "vike:pluginExtractExportNames", "vike:glob", "vike:globalContext", "vike:log", "vike:optimizeDeps", "vike:outDir", "vike:pageFiles", "vike:pointer-imports", "vike:resolve", "vike:routing", "vike:setup", "vike:stream", "vike:virtualFiles"];
+declare const flags: readonly ["vike:crawl", "vike:error", "vike:esbuild-resolve", "vike:pluginExtractAssets", "vike:pluginExtractExportNames", "vike:glob", "vike:globalContext", "vike:log", "vike:optimizeDeps", "vike:outDir", "vike:pageFiles", "vike:pointer-imports", "vike:resolve", "vike:routing", "vike:setup", "vike:stream", "vike:virtualFiles", "vike:vite-rpc"];
 type Flag = (typeof flags)[number];
 type Debug = ReturnType<typeof createDebugger>;
 type Options = {

package/dist/esm/utils/debug.js

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

package/dist/esm/utils/getViteRPC.d.ts

@@ -0,0 +1,6 @@
+export { getViteRPC };
+export { createViteRPC };
+import type { ViteDevServer } from 'vite';
+declare function getViteRPC<RpcFunctions>(): RpcFunctions;
+type AsyncFunction = (...args: any[]) => Promise<unknown>;
+declare function createViteRPC(viteDevServer: ViteDevServer, getRpcFunctions: (viteDevServer: ViteDevServer) => Record<string, AsyncFunction>): void;

package/dist/esm/utils/getViteRPC.js

@@ -0,0 +1,77 @@
+export { getViteRPC }; // consumer (aka RPC client)
+export { createViteRPC }; // provider (aka RPC server)
+import { assert } from './assert.js';
+import { genPromise } from './genPromise.js';
+import { getRandomId } from './getRandomId.js';
+import { getGlobalObject } from './getGlobalObject.js';
+import { createDebugger } from './debug.js';
+import { assertIsNotBrowser } from './assertIsNotBrowser.js';
+assertIsNotBrowser();
+const globalObject = getGlobalObject('utils/getViteRPC.ts', {
+    rpc: null,
+});
+const debug = createDebugger('vike:vite-rpc');
+function getViteRPC() {
+    globalObject.rpc ?? (globalObject.rpc = createRpcClient());
+    return globalObject.rpc;
+}
+function createRpcClient() {
+    // @ts-ignore CJS build doesn't support import.meta — TO-DO/eventually: let's remove this ts-ignore after we removed the CJS build
+    const hot = import.meta.hot;
+    assert(hot);
+    const listeners = [];
+    hot.on(`vike:rpc:response`, (dataResponse) => {
+        if (debug.isActivated)
+            debug('Response received', dataResponse);
+        const { callId, functionReturn } = dataResponse;
+        listeners.forEach((l) => {
+            if (callId !== l.callId)
+                return;
+            l.cb(functionReturn);
+            listeners.splice(listeners.indexOf(l), 1);
+        });
+    });
+    const rpc = new Proxy({}, {
+        get(_, functionName) {
+            return async (...functionArgs) => {
+                // @ts-ignore CJS build doesn't support import.meta — TO-DO/eventually: let's remove this ts-ignore after we removed the CJS build
+                const hot = import.meta.hot;
+                assert(hot);
+                const callId = getRandomId();
+                const { promise, resolve } = genPromise({ timeout: 3 * 1000 });
+                listeners.push({
+                    callId,
+                    cb: (functionReturn) => {
+                        resolve(functionReturn);
+                    },
+                });
+                const dataRequest = { callId, functionName, functionArgs };
+                if (debug.isActivated)
+                    debug('Request sent', dataRequest);
+                // Vite's type is wrong: import.meta.hot.send() does seem to return a promise
+                await hot.send('vike:rpc:request', dataRequest);
+                const functionReturn = await promise;
+                return functionReturn;
+            };
+        },
+    });
+    return rpc;
+}
+function createViteRPC(viteDevServer, getRpcFunctions) {
+    const rpcFunctions = getRpcFunctions(viteDevServer);
+    const { environments } = viteDevServer;
+    for (const envName in environments) {
+        debug('Listening to environment', envName);
+        const env = environments[envName];
+        env.hot.on('vike:rpc:request', async (dataRequest) => {
+            if (debug.isActivated)
+                debug('Request received', dataRequest);
+            const { callId, functionName, functionArgs } = dataRequest;
+            const functionReturn = await rpcFunctions[functionName](...functionArgs);
+            const dataResponse = { callId, functionReturn };
+            if (debug.isActivated)
+                debug('Response sent', dataResponse);
+            env.hot.send('vike:rpc:response', dataResponse);
+        });
+    }
+}

package/dist/esm/utils/isRunnableDevEnvironment.d.ts

@@ -0,0 +1,3 @@
+export { isRunnableDevEnvironment };
+import type { Environment, RunnableDevEnvironment } from 'vite';
+declare function isRunnableDevEnvironment(environment: Environment | undefined): environment is RunnableDevEnvironment;

package/dist/esm/utils/isRunnableDevEnvironment.js

@@ -0,0 +1,7 @@
+export { isRunnableDevEnvironment };
+// We use this instead of `import { isRunnableDevEnvironment } from 'vite'` because:
+// - Vite's isRunnableDevEnvironment() isn't reliable in monorepos where multiple Vite instances can be used simultaneously (it uses `instanceof RunnableDevEnvironment` which fails)
+// - We can use this in Vike's server production runtime without having to load the 'vite' package
+function isRunnableDevEnvironment(environment) {
+    return !!environment && 'runner' in environment && !!environment.runner;
+}