vike 0.4.228 → 0.4.229-commit-a19745d

package/dist/esm/client/server-routing-runtime/createPageContextClientSide.js

@@ -0,0 +1,47 @@
+export { createPageContextClientSide };
+import { assertUsage, assertWarning, augmentType, objectAssign } from './utils.js';
+import { getPageContextSerializedInHtml } from '../shared/getJsonSerializedInHtml.js';
+import { loadUserFilesClientSide } from '../shared/loadUserFilesClientSide.js';
+import { getCurrentUrl } from '../shared/getCurrentUrl.js';
+import { createPageContextShared } from '../../shared/createPageContextShared.js';
+import { getGlobalContextClientInternal } from './globalContext.js';
+const urlFirst = getCurrentUrl({ withoutHash: true });
+async function createPageContextClientSide() {
+    const globalContext = await getGlobalContextClientInternal();
+    const pageContextCreated = {
+        /* Don't spread globalContext for now? Or never spread it as it leads to confusion? The convenience isn't worth the added confusion?
+        ...globalContext, // least precedence
+        */
+        globalContext,
+        _pageFilesAll: globalContext._pageFilesAll,
+        _pageConfigs: globalContext._pageConfigs,
+        _pageConfigGlobal: globalContext._pageConfigGlobal,
+        _allPageIds: globalContext._allPageIds,
+        isPrerendering: false,
+        isClientSide: true,
+        isHydration: true,
+        isBackwardNavigation: null,
+        _hasPageContextFromServer: true,
+        _hasPageContextFromClient: false
+    };
+    objectAssign(pageContextCreated, getPageContextSerializedInHtml());
+    objectAssign(pageContextCreated, await loadPageUserFiles(pageContextCreated.pageId, pageContextCreated));
+    const pageContextAugmented = await createPageContextShared(pageContextCreated, globalContext._pageConfigGlobal);
+    augmentType(pageContextCreated, pageContextAugmented);
+    assertPristineUrl();
+    return pageContextCreated;
+}
+function assertPristineUrl() {
+    const urlCurrent = getCurrentUrl({ withoutHash: true });
+    assertUsage(urlFirst === urlCurrent, `The URL was manipulated before the hydration finished ('${urlFirst}' to '${urlCurrent}'). Ensure the hydration has finished before manipulating the URL. Consider using the onHydrationEnd() hook.`);
+}
+async function loadPageUserFiles(pageId, pageContext) {
+    const pageContextAddendum = {};
+    objectAssign(pageContextAddendum, await loadUserFilesClientSide(pageId, pageContext._pageFilesAll, pageContext._pageConfigs, pageContext._pageConfigGlobal));
+    pageContext._pageFilesAll
+        .filter((p) => p.fileType !== '.page.server')
+        .forEach((p) => {
+        assertWarning(!p.fileExports?.onBeforeRender, `export { onBeforeRender } of ${p.filePath} is loaded in the browser but never executed (because you are using Server-side Routing). In order to reduce the size of you browser-side JavaScript, define onBeforeRender() in a .page.server.js file instead, see https://vike.dev/onBeforeRender-isomorphic#server-routing`, { onlyOnce: true });
+    });
+    return pageContextAddendum;
+}

package/dist/esm/client/server-routing-runtime/entry.js

@@ -1,6 +1,6 @@
 import { assertServerRouting } from '../../utils/assertRoutingType.js';
 assertServerRouting();
-import { getPageContext } from './getPageContext.js';
+import { createPageContextClientSide } from './createPageContextClientSide.js';
 import { executeOnRenderClientHook } from '../shared/executeOnRenderClientHook.js';
 import { assertHook } from '../../shared/hooks/getHook.js';
 import { assertSingleInstance_onClientEntryServerRouting } from './utils.js';
@@ -12,7 +12,7 @@ if (import.meta.env.DEV)
     removeFoucBuster();
 hydrate();
 async function hydrate() {
-    const pageContext = await getPageContext();
+    const pageContext = await createPageContextClientSide();
     await executeOnRenderClientHook(pageContext, false);
     assertHook(pageContext, 'onHydrationEnd');
     await pageContext.exports.onHydrationEnd?.(pageContext);

package/dist/esm/client/server-routing-runtime/globalContext.d.ts

@@ -0,0 +1,17 @@
+export { getGlobalContextClientInternal };
+export type { GlobalContextClientWithServerRouting };
+import type { GlobalContextSharedPublic } from '../../shared/createGlobalContextShared.js';
+type GlobalContextClientWithServerRouting = GlobalContextSharedPublic & Pick<GlobalContextClientInternal, 'isClientSide'> & Vike.GlobalContext & Vike.GlobalContextClient & {};
+type GlobalContextClientInternal = Awaited<ReturnType<typeof getGlobalContextClientInternal>>;
+declare const getGlobalContextClientInternal: () => Promise<{
+    isGlobalContext: true;
+    _virtualFileExports: unknown;
+    _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
+    _pageConfigs: import("../../__internal/index.js").PageConfig[];
+    _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
+    _allPageIds: string[];
+    config: import("../../types/index.js").ConfigResolved;
+    pages: import("../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
+} & {
+    isClientSide: true;
+} & object>;

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

@@ -0,0 +1,5 @@
+export { getGlobalContextClientInternal };
+import { createGetGlobalContextClient } from '../shared/createGetGlobalContextClient.js';
+// @ts-ignore
+import * as virtualFileExports from 'virtual:vike:importUserCode:client:server-routing';
+const getGlobalContextClientInternal = createGetGlobalContextClient(virtualFileExports, false);

package/dist/esm/client/server-routing-runtime/utils.d.ts

@@ -1,6 +1,5 @@
 export * from '../../utils/assert.js';
 export * from '../../utils/assertSingleInstance.js';
-export * from '../../shared/hooks/executeHook.js';
 export * from '../../utils/checkType.js';
 export * from '../../utils/getGlobalObject.js';
 export * from '../../utils/hasProp.js';
@@ -11,3 +10,4 @@ export * from '../../utils/parseUrl.js';
 export * from '../../utils/slice.js';
 export * from '../../utils/unique.js';
 export * from '../../utils/getPropAccessNotation.js';
+export * from '../../utils/augmentType.js';

package/dist/esm/client/server-routing-runtime/utils.js

@@ -4,7 +4,6 @@ import { onLoad } from './onLoad.js';
 onLoad();
 export * from '../../utils/assert.js';
 export * from '../../utils/assertSingleInstance.js';
-export * from '../../shared/hooks/executeHook.js';
 export * from '../../utils/checkType.js'; // Only used by Server Routing (not needed for Client Routing)
 export * from '../../utils/getGlobalObject.js';
 export * from '../../utils/hasProp.js';
@@ -15,3 +14,4 @@ export * from '../../utils/parseUrl.js';
 export * from '../../utils/slice.js';
 export * from '../../utils/unique.js'; // Only used by Server Routing (not needed for Client Routing)
 export * from '../../utils/getPropAccessNotation.js';
+export * from '../../utils/augmentType.js';

package/dist/esm/client/shared/createGetGlobalContextClient.d.ts

@@ -0,0 +1,23 @@
+export { getGlobalContext };
+export { getGlobalContextSync };
+export { createGetGlobalContextClient };
+import { type GlobalContextShared } from '../../shared/createGlobalContextShared.js';
+declare function createGetGlobalContextClient<GlobalContextAddendum extends object>(virtualFileExports: unknown, isClientRouting: boolean, addGlobalContext?: (globalContext: GlobalContextShared) => Promise<GlobalContextAddendum>): () => Promise<{
+    isGlobalContext: true;
+    _virtualFileExports: unknown;
+    _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
+    _pageConfigs: import("../../__internal/index.js").PageConfig[];
+    _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
+    _allPageIds: string[];
+    config: import("../../types/index.js").ConfigResolved;
+    pages: import("../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
+} & Awaited<{
+    /**
+     * Whether the environment is client-side or server-side / pre-rendering.
+     *
+     * We recommend using `import.meta.env.SSR` instead, see https://vike.dev/globalContext
+     */
+    isClientSide: true;
+} & Awaited<GlobalContextAddendum>>>;
+declare function getGlobalContext(): Promise<never>;
+declare function getGlobalContextSync(): never;

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

@@ -0,0 +1,58 @@
+// Public usage
+export { getGlobalContext };
+export { getGlobalContextSync };
+// Internal usage
+export { createGetGlobalContextClient };
+import { createGlobalContextShared, getGlobalContextSyncErrMsg } from '../../shared/createGlobalContextShared.js';
+import { getGlobalContextSerializedInHtml } from './getJsonSerializedInHtml.js';
+import { assert, assertUsage, genPromise, getGlobalObject, objectAssign } from './utils.js';
+const globalObject = getGlobalObject('createGetGlobalContextClient.ts', (() => {
+    const { promise: globalContextPromise, resolve: globalContextPromiseResolve } = genPromise();
+    return {
+        globalContextPromise,
+        globalContextPromiseResolve
+    };
+})());
+function createGetGlobalContextClient(virtualFileExports, isClientRouting, addGlobalContext) {
+    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;
+        }
+        // Create
+        const globalContext = await createGlobalContextShared(virtualFileExports, globalObject, 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
+                 */
+                isClientSide: true
+            };
+            objectAssign(globalContextAddendum, getGlobalContextSerializedInHtml());
+            objectAssign(globalContextAddendum, await addGlobalContext?.(globalContext));
+            return globalContextAddendum;
+        });
+        assert(globalObject.globalContext);
+        globalObject.globalContextPromiseResolve(globalObject.globalContext);
+        // Return
+        return globalContext;
+    }
+}
+// The type is never used: it's the type of the server-side getGlobalContext() that is used.
+async function getGlobalContext() {
+    const globalContext = await globalObject.globalContextPromise;
+    return globalContext;
+}
+function getGlobalContextSync() {
+    const { globalContext } = globalObject;
+    assertUsage(globalContext, getGlobalContextSyncErrMsg);
+    return globalContext;
+}

package/dist/esm/client/shared/executeOnRenderClientHook.js

@@ -1,18 +1,19 @@
 export { executeOnRenderClientHook };
-import { assert, assertUsage, executeHook } from '../server-routing-runtime/utils.js';
-import { getHook } from '../../shared/hooks/getHook.js';
+import { assert, assertUsage } from '../server-routing-runtime/utils.js';
+import { getHookFromPageContext } from '../../shared/hooks/getHook.js';
 import { preparePageContextForUserConsumptionClientSide } from './preparePageContextForUserConsumptionClientSide.js';
+import { executeHook } from '../../shared/hooks/executeHook.js';
 async function executeOnRenderClientHook(pageContext, isClientRouting) {
     const pageContextForUserConsumption = preparePageContextForUserConsumptionClientSide(pageContext, isClientRouting);
     let hook = null;
     let hookName;
     {
-        const renderHook = getHook(pageContext, 'render');
+        const renderHook = getHookFromPageContext(pageContext, 'render');
         hook = renderHook;
         hookName = 'render';
     }
     {
-        const renderHook = getHook(pageContext, 'onRenderClient');
+        const renderHook = getHookFromPageContext(pageContext, 'onRenderClient');
         if (renderHook) {
             hook = renderHook;
             hookName = 'onRenderClient';

package/dist/esm/client/shared/{getPageContextSerializedInHtml.d.ts → getJsonSerializedInHtml.d.ts}

@@ -1,5 +1,7 @@
 export { getPageContextSerializedInHtml };
+export { getGlobalContextSerializedInHtml };
 declare function getPageContextSerializedInHtml(): {
     pageId: string;
     routeParams: Record<string, string>;
 };
+declare function getGlobalContextSerializedInHtml(): object;

package/dist/esm/client/shared/getJsonSerializedInHtml.js

@@ -0,0 +1,29 @@
+export { getPageContextSerializedInHtml };
+export { getGlobalContextSerializedInHtml };
+import { parse } from '@brillout/json-serializer/parse';
+import { hasProp, assert, assertUsage } from './utils.js';
+import { htmlElementId_globalContext, htmlElementId_pageContext } from '../../shared/htmlElementIds.js';
+// elements should exist because:
+// 1. <script id="vike_pageContext" type="application/json"> appears before the <script> that loads Vike's client runtime (which includes this file)
+// 2. <script id="vike_pageContext" type="application/json"> is neither async nor defer
+// See https://github.com/vikejs/vike/pull/1271
+function getPageContextSerializedInHtml() {
+    const pageContextSerializedInHtml = findAndParseJson(htmlElementId_pageContext);
+    assert(hasProp(pageContextSerializedInHtml, 'pageId', 'string'));
+    assert(hasProp(pageContextSerializedInHtml, 'routeParams', 'string{}'));
+    return pageContextSerializedInHtml;
+}
+function getGlobalContextSerializedInHtml() {
+    const globalContextSerializedInHtml = findAndParseJson(htmlElementId_globalContext);
+    return globalContextSerializedInHtml;
+}
+function findAndParseJson(id) {
+    const elem = document.getElementById(id);
+    assertUsage(elem, 
+    // It seems like it can be missing when HTML is malformed: https://github.com/vikejs/vike/issues/913
+    `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;
+    assert(jsonStr);
+    const json = parse(jsonStr);
+    return json;
+}

package/dist/esm/client/shared/removeFoucBuster.js

@@ -6,6 +6,7 @@ import { assert } from './utils.js';
 //   - https://github.com/rakkasjs/rakkasjs/blob/7d75ccc915e93bca04e6bab37dc6abdb68a85e4a/packages/rakkasjs/src/features/pages/middleware.tsx#L701
 // - https://github.com/remix-run/remix/issues/8830
 function removeFoucBuster() {
+    // In production removeFoucBuster() is expected to be have been removed by tree shaking
     assert(import.meta.env.DEV);
     let sleep = 2;
     setTimeout(runClean, sleep);

package/dist/esm/client/shared/utils.d.ts

@@ -1,2 +1,6 @@
 export * from '../../utils/assert.js';
 export * from '../../utils/parseUrl.js';
+export * from '../../utils/getGlobalObject.js';
+export * from '../../utils/objectAssign.js';
+export * from '../../utils/hasProp.js';
+export * from '../../utils/genPromise.js';

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

@@ -1,2 +1,6 @@
 export * from '../../utils/assert.js';
 export * from '../../utils/parseUrl.js';
+export * from '../../utils/getGlobalObject.js';
+export * from '../../utils/objectAssign.js';
+export * from '../../utils/hasProp.js';
+export * from '../../utils/genPromise.js';

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

@@ -21,6 +21,7 @@ import { setResolveClientEntriesDev } from '../runtime/renderPage/getPageAssets.
 import { resolveClientEntriesDev } from './shared/resolveClientEntriesDev.js';
 import { workaroundCssModuleHmr } from './plugins/workaroundCssModuleHmr.js';
 import { workaroundVite6HmrRegression } from './plugins/workaroundVite6HmrRegression.js';
+import { replaceConstants } from './plugins/replaceConstants.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
@@ -38,7 +39,8 @@ function plugin(vikeVitePluginOptions = {}) {
         envVarsPlugin(),
         fileEnv(),
         workaroundCssModuleHmr(),
-        workaroundVite6HmrRegression()
+        workaroundVite6HmrRegression(),
+        replaceConstants()
     ];
     Object.assign(plugins, { __vikeVitePluginOptions: vikeVitePluginOptions });
     return plugins;

package/dist/esm/node/plugin/plugins/baseUrls.js

@@ -2,7 +2,7 @@ export { baseUrls };
 import { resolveBase } from '../../shared/resolveBase.js';
 import { assert } from '../utils.js';
 import { getVikeConfig } from './importUserCode/v1-design/getVikeConfig.js';
-import { getVikeConfigPublic } from './commonConfig.js';
+import { getVikeConfigInternal } from './commonConfig.js';
 function baseUrls() {
     let basesResolved;
     return {
@@ -12,7 +12,7 @@ function baseUrls() {
             const isDev = config._isDev;
             assert(typeof isDev === 'boolean');
             const baseViteOriginal = config.base ?? '/__UNSET__'; // '/__UNSET__' because Vite resolves `_baseViteOriginal: null` to `undefined`
-            const vike = getVikeConfigPublic(config);
+            const vike = getVikeConfigInternal(config);
             basesResolved = resolveBase(baseViteOriginal, vike.config.baseServer ?? null, vike.config.baseAssets ?? null);
             // We cannot define these in configResolved() because Vite picks up the env variables before any configResolved() hook is called
             process.env.BASE_SERVER = basesResolved.baseServer;

package/dist/esm/node/plugin/plugins/build/handleAssetsManifest.js

@@ -15,7 +15,7 @@ import pc from '@brillout/picocolors';
 import { isV1Design } from '../importUserCode/v1-design/getVikeConfig.js';
 import { getOutDirs } from '../../shared/getOutDirs.js';
 import { isViteServerBuild_onlySsrEnv, isViteServerBuild } from '../../shared/isViteServerBuild.js';
-import { getVikeConfigPublic } from '../commonConfig.js';
+import { getVikeConfigInternal } from '../commonConfig.js';
 import { set_macro_ASSETS_MANIFEST } from './pluginBuildEntry.js';
 assertIsSingleModuleInstance('build/handleAssetsManifest.ts');
 let assetsJsonFilePath;
@@ -281,7 +281,7 @@ async function writeManifestFile(manifest, manifestFilePath) {
     await fs.writeFile(manifestFilePath, manifestFileContent, 'utf-8');
 }
 function handleAssetsManifest_getBuildConfig(config) {
-    const vike = getVikeConfigPublic(config);
+    const vike = getVikeConfigInternal(config);
     const isFixEnabled = handleAssetsManifest_isFixEnabled(config);
     return {
         // https://github.com/vikejs/vike/issues/1339
@@ -296,16 +296,21 @@ function handleAssetsManifest_getBuildConfig(config) {
     };
 }
 async function handleAssetsManifest(config, viteEnv, options, bundle) {
-    if (isViteServerBuild_onlySsrEnv(config, viteEnv)) {
+    const isSsREnv = isViteServerBuild_onlySsrEnv(config, viteEnv);
+    if (isSsREnv) {
         assert(!assetsJsonFilePath);
         const outDirs = getOutDirs(config, viteEnv);
         assetsJsonFilePath = path.posix.join(outDirs.outDirRoot, 'assets.json');
         await writeAssetsManifestFile(outDirs, assetsJsonFilePath, config);
     }
     if (isViteServerBuild(config, viteEnv)) {
-        assert(assetsJsonFilePath);
-        // Replace __VITE_ASSETS_MANIFEST__ in all server-side bundles
-        await set_macro_ASSETS_MANIFEST(options, bundle, assetsJsonFilePath);
+        // Replace __VITE_ASSETS_MANIFEST__ in server builds
+        // - Always replace it in dist/server/
+        // - 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 set_macro_ASSETS_MANIFEST(options, bundle, assetsJsonFilePath);
+        if (isSsREnv)
+            assert(!noop); // dist/server should always contain __VITE_ASSETS_MANIFEST__
     }
 }
 async function writeAssetsManifestFile(outDirs, assetsJsonFilePath, config) {

package/dist/esm/node/plugin/plugins/build/pluginBuildApp.js

@@ -2,7 +2,7 @@ export { pluginBuildApp };
 import { runPrerender_forceExit } from '../../../prerender/runPrerender.js';
 import { resolveOutDir } from '../../shared/getOutDirs.js';
 import { assert } from '../../utils.js';
-import { getVikeConfigPublic } from '../commonConfig.js';
+import { getVikeConfigInternal } from '../commonConfig.js';
 import { isPrerenderForceExit } from './pluginAutoFullBuild.js';
 function pluginBuildApp() {
     return [
@@ -10,7 +10,7 @@ function pluginBuildApp() {
             name: 'vike:build:pluginBuildApp',
             apply: 'build',
             config(config) {
-                const vike = getVikeConfigPublic(config);
+                const vike = getVikeConfigInternal(config);
                 if (!vike.config.vite6BuilderApp)
                     return;
                 return {

package/dist/esm/node/plugin/plugins/build/pluginBuildConfig.js

@@ -2,7 +2,7 @@ export { pluginBuildConfig };
 export { assertRollupInput };
 export { analyzeClientEntries };
 export { manifestTempFile };
-import { assert, addOnBeforeLogHook, removeFileExtention, unique, assertUsage, injectRollupInputs, normalizeRollupInput, onSetupBuild, assertIsNpmPackageImport, requireResolveNonUserFile } from '../../utils.js';
+import { assert, addOnBeforeLogHook, removeFileExtention, unique, assertUsage, injectRollupInputs, normalizeRollupInput, onSetupBuild, assertIsImportPathNpmPackage, requireResolveVikeDistFile } from '../../utils.js';
 import { getVikeConfig } from '../importUserCode/v1-design/getVikeConfig.js';
 import { findPageFiles } from '../../shared/findPageFiles.js';
 import { getVirtualFileIdPageConfigValuesAll } from '../../../shared/virtual-files/virtualFilePageConfigValuesAll.js';
@@ -13,8 +13,6 @@ import { getConfigValueBuildTime } from '../../../../shared/page-configs/getConf
 import { isViteServerBuild } from '../../shared/isViteServerBuild.js';
 import { resolveOutDir } from '../../shared/getOutDirs.js';
 import { handleAssetsManifest_assertUsageCssCodeSplit, handleAssetsManifest_getBuildConfig } from './handleAssetsManifest.js';
-// @ts-ignore import.meta.url is shimmed at dist/cjs by dist-cjs-fixup.js.
-const importMetaUrl = import.meta.url;
 const manifestTempFile = '_temp_manifest.json';
 function pluginBuildConfig() {
     let config;
@@ -81,8 +79,8 @@ async function getEntries(config) {
             ...clientEntries,
             ...pageFileEntries
         };
-        const clientRoutingEntry = resolve(`dist/esm/client/client-routing-runtime/entry.js`);
-        const serverRoutingEntry = resolve(`dist/esm/client/server-routing-runtime/entry.js`);
+        const clientRoutingEntry = requireResolveVikeDistFile('dist/esm/client/client-routing-runtime/entry.js');
+        const serverRoutingEntry = requireResolveVikeDistFile('dist/esm/client/server-routing-runtime/entry.js');
         if (hasClientRouting) {
             entries['entries/entry-client-routing'] = clientRoutingEntry;
         }
@@ -156,7 +154,7 @@ async function getPageFileEntries(config, includeAssetsImportedByServer) {
 }
 function getEntryFromClientEntry(clientEntry, config, addExtractAssetsQuery) {
     if (!clientEntry.startsWith('/')) {
-        assertIsNpmPackageImport(clientEntry);
+        assertIsImportPathNpmPackage(clientEntry);
         const entryTarget = clientEntry;
         const entryName = prependEntriesDir(clientEntry);
         return { entryName, entryTarget };
@@ -192,11 +190,6 @@ function getEntryFromPageConfig(pageConfig, isForClientSide) {
     assert(!entryName.endsWith('/'));
     return { entryName, entryTarget };
 }
-function resolve(filePath) {
-    assert(filePath.startsWith('dist/'));
-    // [RELATIVE_PATH_FROM_DIST] Current directory: node_modules/vike/dist/esm/node/plugin/plugins/build/
-    return requireResolveNonUserFile(`../../../../../../${filePath}`, importMetaUrl);
-}
 function addLogHook() {
     const tty = process.stdout.isTTY && !process.env.CI; // Equals https://github.com/vitejs/vite/blob/193d55c7b9cbfec5b79ebfca276d4a721e7de14d/packages/vite/src/node/plugins/reporter.ts#L27
     if (!tty)

package/dist/esm/node/plugin/plugins/build/pluginBuildEntry.d.ts

@@ -4,4 +4,4 @@ import type { Plugin, Rollup } from 'vite';
 type Bundle = Rollup.OutputBundle;
 type Options = Rollup.NormalizedOutputOptions;
 declare function pluginBuildEntry(): Plugin[];
-declare function set_macro_ASSETS_MANIFEST(options: Options, bundle: Bundle, assetsJsonFilePath: string): Promise<void>;
+declare function set_macro_ASSETS_MANIFEST(options: Options, bundle: Bundle, assetsJsonFilePath: string | undefined): Promise<boolean>;

package/dist/esm/node/plugin/plugins/build/pluginBuildEntry.js

@@ -2,11 +2,9 @@ export { pluginBuildEntry };
 export { set_macro_ASSETS_MANIFEST };
 import { serverProductionEntryPlugin } from '@brillout/vite-plugin-server-entry/plugin';
 import { virtualFileIdImportUserCodeServer } from '../../../shared/virtual-files/virtualFileImportUserCode.js';
-import { assert, PROJECT_VERSION, requireResolveNonUserFile } from '../../utils.js';
+import { assert, PROJECT_VERSION, requireResolveVikeDistFile } from '../../utils.js';
 import fs from 'fs/promises';
 import path from 'path';
-// @ts-ignore import.meta.url is shimmed at dist/cjs by dist-cjs-fixup.js.
-const importMetaUrl = import.meta.url;
 import { isUsingClientRouter } from '../extractExportNamesPlugin.js';
 import { assertBuildInfo } from '../../../runtime/globalContext.js';
 import { getOutDirs } from '../../shared/getOutDirs.js';
@@ -63,6 +61,12 @@ async function set_macro_ASSETS_MANIFEST(options, bundle, assetsJsonFilePath) {
     const { dir } = options;
     assert(dir);
     const chunkPath = find_ASSETS_MANIFEST(bundle);
+    // Some server builds don't contain __VITE_ASSETS_MANIFEST__ such as dist/rsc/ from vike-react-rsc
+    if (!chunkPath) {
+        const noop = true; // no operation
+        return noop;
+    }
+    assert(assetsJsonFilePath);
     const chunkFilePath = path.join(dir, chunkPath);
     const [assetsJsonString, chunkFileContent] = await Promise.all([
         await fs.readFile(assetsJsonFilePath, 'utf8'),
@@ -71,6 +75,8 @@ async function set_macro_ASSETS_MANIFEST(options, bundle, assetsJsonFilePath) {
     const serverEntryFileContentPatched = chunkFileContent.replace(ASSETS_MANIFEST, assetsJsonString);
     assert(serverEntryFileContentPatched !== chunkFileContent);
     await fs.writeFile(chunkFilePath, serverEntryFileContentPatched);
+    const noop = false;
+    return noop;
 }
 function find_ASSETS_MANIFEST(bundle) {
     let chunkPath;
@@ -81,13 +87,11 @@ function find_ASSETS_MANIFEST(bundle) {
             chunkPath = filePath;
         }
     }
-    assert(chunkPath);
     return chunkPath;
 }
 function getImportPath(config) {
     // We resolve filePathAbsolute even if we don't use it: we use require.resolve() as an assertion that the relative path is correct
-    // [RELATIVE_PATH_FROM_DIST] Current file: node_modules/vike/dist/esm/node/plugin/plugins/pluginBuildEntry/index.js
-    const filePathAbsolute = requireResolveNonUserFile(`../../../../../../dist/esm/__internal/index.js`, importMetaUrl);
+    const filePathAbsolute = requireResolveVikeDistFile('dist/esm/__internal/index.js');
     if (
     // Let's implement a new config if a user needs the import to be a relative path instead of 'vike/__internal' (AFAIK a relative path is needed only if a framework has npm package 'vike' as direct dependency instead of a peer dependency and if the user of that framework uses pnpm)
     true) {

package/dist/esm/node/plugin/plugins/build/pluginModuleBanner.js

@@ -16,21 +16,25 @@ function pluginModuleBanner() {
         transform: {
             order: 'post',
             handler(code, id, options) {
-                if (!isViteServerBuild_safe(config, options))
+                if (!isViteServerBuild_safe(config, options) &&
+                    // Inject module banners if user sets `build.minify` to `false` for inspecting dist/client/
+                    config.build.minify) {
                     return;
+                }
                 if (id.startsWith('\0'))
                     id = id;
                 id = removeVirtualIdTag(id);
                 if (id.startsWith(config.root))
                     id = id.slice(config.root.length + 1);
-                const s = new MagicString(code);
+                id = id.replaceAll('*/', '*\\/'); // https://github.com/vikejs/vike/issues/2377
+                const magicString = new MagicString(code);
                 // Use legal comment so that esbuild doesn't remove it.
                 // - Terser still removes the comment, but I guess users use terser to minify JavaScript so I guess it's a good thing that comment is removed.
                 // - https://esbuild.github.io/api/#legal-comments
-                s.prepend(`/*! ${id} [vike:pluginModuleBanner] */\n`);
+                magicString.prepend(`/*! ${id} [vike:pluginModuleBanner] */\n`);
                 return {
-                    code: s.toString(),
-                    map: s.generateMap({ hires: true, source: id })
+                    code: magicString.toString(),
+                    map: magicString.generateMap({ hires: true, source: id })
                 };
             }
         }

package/dist/esm/node/plugin/plugins/commonConfig/assertResolveAlias.js

@@ -1,5 +1,5 @@
 export { assertResolveAlias };
-import { assert, assertUsage, assertWarning, isArray, isValidPathAlias } from '../../utils.js';
+import { assert, assertUsage, assertWarning, isArray, isPathAliasRecommended } from '../../utils.js';
 import pc from '@brillout/picocolors';
 // Recommend users to avoid un-distinguishable path aliases.
 // There are a lot of libraries that don't or cannot follow that recommendation, for example:
@@ -59,7 +59,7 @@ function assertResolveAlias(config) {
             //  - determineOptimizeDeps()
             //  - extractAssets
             //  - in general: using un-distinguishable path aliases is asking for trouble
-            if (!isValidPathAlias(find)) {
+            if (!isPathAliasRecommended(find)) {
                 if (find.startsWith('@')) {
                     const msg = `${errPrefix} defines an invalid resolve.alias ${deprecation}: a path alias cannot start with ${pc.cyan('@')}, ${errSuffix1}`;
                     assertWarning(false, msg, { onlyOnce: true });

package/dist/esm/node/plugin/plugins/commonConfig.d.ts

@@ -1,5 +1,6 @@
 export { commonConfig };
 export { getVikeConfigPublic };
+export { getVikeConfigInternal };
 export type { VikeConfigPublic };
 import { type InlineConfig, type Plugin, type ResolvedConfig, type UserConfig } from 'vite';
 import { type VikeConfigObject } from './importUserCode/v1-design/getVikeConfig.js';
@@ -34,4 +35,5 @@ declare function commonConfig(vikeVitePluginOptions: unknown): Plugin[];
  *
  * https://vike.dev/getVikeConfig
  */
+declare function getVikeConfigInternal(config: ResolvedConfig | UserConfig): VikeConfigPublic;
 declare function getVikeConfigPublic(config: ResolvedConfig | UserConfig): VikeConfigPublic;

package/dist/esm/node/plugin/plugins/commonConfig.js

@@ -1,6 +1,7 @@
 export { commonConfig };
 export { getVikeConfigPublic };
-import { assert, assertUsage, assertWarning, findPackageJson, hasProp, isDevCheck, isDocker, isObject } from '../utils.js';
+export { getVikeConfigInternal };
+import { assert, assertUsage, assertWarning, findPackageJson, hasProp, isDevCheck, isDocker, isObject, isVitest } from '../utils.js';
 import { assertRollupInput } from './build/pluginBuildConfig.js';
 import { installRequireShim_setUserRootDir } from '@brillout/require-shim';
 import pc from '@brillout/picocolors';
@@ -85,7 +86,7 @@ function commonConfig(vikeVitePluginOptions) {
                 order: 'post',
                 handler(configFromUser) {
                     let configFromVike = { server: {}, preview: {} };
-                    const vike = getVikeConfigPublic(configFromUser);
+                    const vike = getVikeConfigInternal(configFromUser);
                     if (vike.config.port !== undefined) {
                         // https://vike.dev/port
                         setDefault('port', vike.config.port, configFromUser, configFromVike);
@@ -153,11 +154,16 @@ function assertVikeCliOrApi(config) {
     if (isVikeCliOrApi())
         return;
     if (isViteCliCall()) {
+        assert(!isVitest());
         assertWarning(false, `Vite's CLI is deprecated ${pc.underline('https://vike.dev/migration/cli')}`, {
             onlyOnce: true
         });
         return;
     }
+    if (isVitest()) {
+        assertWarning(false, `Unexpected Vitest setup: you seem to be using Vitest together with Vike's Vite plugin but without using Vike's JavaScript API which is unexpected, see ${pc.underline('https://vike.dev/vitest')}`, { onlyOnce: true });
+        return;
+    }
     if (config.server.middlewareMode) {
         assertWarning(false, `${pc.cyan('vite.createServer()')} is deprecated ${pc.underline('https://vike.dev/migration/cli#api')}`, {
             onlyOnce: true
@@ -191,7 +197,7 @@ function temp_supportOldInterface(config) {
 }
 // TODO/soon rename:
 // - `getVikeConfig()` => `resolveVikeConfig()` ?
-// - `getVikeConfigPublic()` => `getVikeConfig()`
+// - `getVikeConfigInternal()` => `getVikeConfig()`
 // - `VikeConfigPublic` => `VikeConfig` ?
 // - `VikeConfigObject` => `VikeConfigInternal` ?
 /**
@@ -199,11 +205,16 @@ function temp_supportOldInterface(config) {
  *
  * https://vike.dev/getVikeConfig
  */
-function getVikeConfigPublic(config) {
+function getVikeConfigInternal(config) {
     const vikeConfig = config._vike;
     assert(vikeConfig);
     return vikeConfig;
 }
+function getVikeConfigPublic(config) {
+    const vikeConfig = config._vike;
+    assertUsage(vikeConfig, "getVikeConfig() can only be used when Vite is running with Vike's Vite plugin");
+    return vikeConfig;
+}
 // Only emit dist/server/entry.mjs if necessary
 function emitServerEntryOnlyIfNeeded(config) {
     if (config.vitePluginServerEntry?.inject &&