vike 0.4.162 → 0.4.163-commit-407cb5c

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

@@ -1,10 +1,6 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getHint = exports.isKnownError = exports.isCjsEsmError = exports.logErrorHint = void 0;
-const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const utils_js_1 = require("../utils.js");
 const knownErrors = [
     {
@@ -14,6 +10,13 @@ const knownErrors = [
     {
         errMsg: 'Element type is invalid: expected a string (for built-in components) or a class/function (for composite components)',
         link: 'https://vike.dev/broken-npm-package#react-invalid-component'
+    },
+    {
+        // ```
+        // Error [RollupError]: Could not resolve "../dist/client/assets.json" from "renderer/+onRenderHtml.tsx"
+        // ```
+        errMsg: 'assets.json',
+        link: 'https://vike.dev/getGlobalContext'
     }
 ];
 function logErrorHint(error) {
@@ -33,15 +36,7 @@ function getHint(error) {
     }
     const res = isCjsEsmError(error);
     if (res) {
-        const packageNames = res === true ? null : res;
-        const hint = [
-            'Error could be a CJS/ESM issue, consider ',
-            !packageNames || packageNames.length === 0
-                ? 'using'
-                : `adding ${(0, utils_js_1.joinEnglish)(packageNames.map((p) => picocolors_1.default.cyan(p)), 'or')} to`,
-            ` ${picocolors_1.default.cyan('ssr.noExternal')}`,
-            ', see https://vike.dev/broken-npm-package'
-        ].join('');
+        const hint = 'The error seems to be a CJS/ESM issue, see https://vike.dev/broken-npm-package';
         return hint;
     }
     return null;
@@ -74,6 +69,7 @@ function isCjsEsmError(error) {
     packageNames.forEach((packageName) => {
         (0, utils_js_1.assert)(!['vite', 'vike'].includes(packageName));
     });
+    // We don't use this anymore: we could return `true` instead. Shall we remove returning a list of npm packages?
     return packageNames;
 }
 exports.isCjsEsmError = isCjsEsmError;

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

@@ -327,6 +327,9 @@ function normalizeUrl(pageContextInit, httpRequestId) {
     if (disableUrlNormalization)
         return null;
     const { urlOriginal } = pageContextInit;
+    const { isPageContextRequest } = (0, handlePageContextRequestUrl_js_1.handlePageContextRequestUrl)(urlOriginal);
+    if (isPageContextRequest)
+        return null;
     const urlNormalized = (0, utils_js_1.normalizeUrlPathname)(urlOriginal, trailingSlash, baseServer);
     if (!urlNormalized)
         return null;

package/dist/cjs/shared/page-configs/serialize/serializeConfigValue.js

@@ -1,7 +1,4 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.serializeConfigValueImported = exports.serializeConfigValue = void 0;
 // This file is never loaded on the client-side but we save it under the vike/shared/ directory in order to collocate it with:
@@ -10,7 +7,6 @@ exports.serializeConfigValueImported = exports.serializeConfigValue = void 0;
 // Both parsePageConfigs() parseConfigValuesImported() and are loaded on the client-side and server-side
 const assertIsNotProductionRuntime_js_1 = require("../../../utils/assertIsNotProductionRuntime.js");
 (0, assertIsNotProductionRuntime_js_1.assertIsNotProductionRuntime)();
-const path_1 = __importDefault(require("path"));
 const utils_js_1 = require("../../utils.js");
 const generateEagerImport_js_1 = require("../../../node/plugin/plugins/importUserCode/generateEagerImport.js");
 function serializeConfigValue(lines, configName, configValueSerialized) {
@@ -28,13 +24,10 @@ exports.serializeConfigValue = serializeConfigValue;
 function serializeConfigValueImported(configValueSource, configName, whitespace, varCounterContainer, importStatements) {
     (0, utils_js_1.assert)(!configValueSource.valueIsFilePath);
     (0, utils_js_1.assert)(whitespace.replaceAll(' ', '').length === 0);
-    const { valueIsImportedAtRuntime, definedAt } = configValueSource;
+    const { valueIsImportedAtRuntime, valueIsDefinedByValueFile, definedAt } = configValueSource;
     (0, utils_js_1.assert)(valueIsImportedAtRuntime);
     const { filePathAbsoluteVite, fileExportName } = definedAt;
-    (0, utils_js_1.assertPosixPath)(filePathAbsoluteVite);
-    const fileName = path_1.default.posix.basename(filePathAbsoluteVite);
-    const isValueFile = fileName.startsWith('+');
-    if (isValueFile)
+    if (valueIsDefinedByValueFile)
         (0, utils_js_1.assert)(fileExportName === undefined);
     const { importName, importStatement } = (0, generateEagerImport_js_1.generateEagerImport)(filePathAbsoluteVite, varCounterContainer.varCounter++, fileExportName);
     importStatements.push(importStatement);
@@ -42,8 +35,8 @@ function serializeConfigValueImported(configValueSource, configName, whitespace,
     lines.push(`  {`);
     lines.push(`    configName: '${configName}',`);
     lines.push(`    importPath: '${filePathAbsoluteVite}',`);
-    lines.push(`    isValueFile: ${JSON.stringify(isValueFile)},`);
-    if (isValueFile) {
+    lines.push(`    isValueFile: ${JSON.stringify(valueIsDefinedByValueFile)},`);
+    if (valueIsDefinedByValueFile) {
         lines.push(`    exportValues: ${importName},`);
     }
     else {

package/dist/cjs/utils/projectInfo.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PROJECT_VERSION = exports.projectInfo = void 0;
 const assertSingleInstance_js_1 = require("./assertSingleInstance.js");
-const PROJECT_VERSION = '0.4.162';
+const PROJECT_VERSION = '0.4.163-commit-407cb5c';
 exports.PROJECT_VERSION = PROJECT_VERSION;
 const projectInfo = {
     projectName: 'Vike',

package/dist/esm/client/client-routing-runtime/renderPageClientSide.js

@@ -308,35 +308,41 @@ async function renderPageClientSide(renderArgs) {
                 }
             }
         };
-        // We use globalObject.renderPromise in order to ensure that there is never two concurrent onRenderClient() calls
-        if (globalObject.renderPromise) {
+        // We use globalObject.onRenderClientPromise in order to ensure that there is never two concurrent onRenderClient() calls
+        if (globalObject.onRenderClientPromise) {
             // Make sure that the previous render has finished
-            await globalObject.renderPromise;
-            assert(globalObject.renderPromise === undefined);
+            await globalObject.onRenderClientPromise;
+            assert(globalObject.onRenderClientPromise === undefined);
             if (isRenderOutdated())
                 return;
         }
         changeUrl(urlOriginal, overwriteLastHistoryEntry);
         globalObject.previousPageContext = pageContext;
-        assert(globalObject.renderPromise === undefined);
-        globalObject.renderPromise = (async () => {
+        assert(globalObject.onRenderClientPromise === undefined);
+        globalObject.onRenderClientPromise = (async () => {
+            let onRenderClientError;
             try {
                 await executeOnRenderClientHook(pageContext, true);
             }
             catch (err) {
-                await onError(err);
-                return;
+                onRenderClientError = err;
             }
-            addLinkPrefetchHandlers(pageContext);
-            globalObject.renderPromise = undefined;
+            globalObject.onRenderClientPromise = undefined;
+            return onRenderClientError;
         })();
-        await globalObject.renderPromise;
-        assert(globalObject.renderPromise === undefined);
+        const onRenderClientError = await globalObject.onRenderClientPromise;
+        assert(globalObject.onRenderClientPromise === undefined);
+        if (onRenderClientError) {
+            await onError(onRenderClientError);
+            if (!isErrorPage)
+                return;
+        }
         /* We don't abort in order to ensure that onHydrationEnd() is called: we abort only after onHydrationEnd() is called.
         if (isRenderOutdated(true)) return
         */
+        addLinkPrefetchHandlers(pageContext);
         // onHydrationEnd()
-        if (isHydrationRender) {
+        if (isHydrationRender && !onRenderClientError) {
             assertHook(pageContext, 'onHydrationEnd');
             const hook = getHook(pageContext, 'onHydrationEnd');
             if (hook) {
@@ -353,7 +359,7 @@ async function renderPageClientSide(renderArgs) {
                     return;
             }
         }
-        // We abort *after* onHydrationEnd() is called
+        // We purposely abort *after* onHydrationEnd() is called (see comment above).
         if (isRenderOutdated(true))
             return;
         // onPageTransitionEnd()

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

@@ -1,5 +1,5 @@
 export { getPageContextProxyForUser };
-import { assert, assertUsage, getGlobalObject } from '../server-routing-runtime/utils.js';
+import { assert, assertUsage, assertWarning, getGlobalObject } from '../server-routing-runtime/utils.js';
 import { notSerializable } from '../../shared/notSerializable.js';
 const globalObject = getGlobalObject('getPageContextProxyForUser.ts', {});
 /**
@@ -30,6 +30,10 @@ function assertIsDefined(pageContext, prop) {
         return;
     if (isExpected(prop))
         return;
+    // - If no pageContext was fetchd from the server, then adding props to passToClient is useless.
+    // - Showing a warning, even though no pageContext was fetched from the server, is actually erroneous as the client runtime cannot deduce the passToClient list.
+    if (!pageContext._hasPageContextFromServer)
+        return;
     const propName = JSON.stringify(prop);
     /* This handling would be the clearest but, unfortunately, it's fundamentally problematic:
      *  - It would force the pageContext value consumer to be synchronized with the pageContext value provider. For example, if vike-react wants to conditionally do something dependening on wehther some optional pageContext value was provided by some optional vike-react-* integration package.
@@ -37,7 +41,7 @@ function assertIsDefined(pageContext, prop) {
     const errMsg = `pageContext[${propName}] is \`undefined\` on the client-side. If it's defined on the server-side then add ${propName} to passToClient (https://vike.dev/passToClient), otherwise make sure your client-side hooks always define it (e.g. set it to \`null\` instead of \`undefined\`).`
     assertUsage(false, errMsg)
     */
-    if (pageContext._hasPageContextFromServer && !pageContext._hasPageContextFromClient) {
+    if (!pageContext._hasPageContextFromClient) {
         // We can safely assume that the property is missing in passToClient, because the server-side defines all passToClient properties even if they have an undefined value:
         // ```
         // <script id="vike_pageContext" type="application/json">{"_pageId":"/pages/admin","user":"!undefined","pageProps":"!undefined","title":"!undefined","abortReason":"!undefined","_urlRewrite":null}</script>
@@ -47,6 +51,19 @@ function assertIsDefined(pageContext, prop) {
     }
     else {
         // Do nothing, not even a warning, because we don't know whether the user expects that the pageContext value can be undefined. (E.g. a pageContext value that is defined by an optional hook.)
+        // TODO/next-major-release make it an assertUsage()
+        assertWarning(false, [
+            `pageContext[${propName}] isn't defined on the client-side:`,
+            `1. if it's defined by the server-side then add ${propName} to passToClient (https://vike.dev/passToClient), or`,
+            `2. if it's expected that it may not be defined:`,
+            '   ```js',
+            '   // ❌ Replace code like this:',
+            `   const val = pageContext[${propName}] ?? someDefaultValue`,
+            '   // ✅ With that:',
+            `   const val = ${propName} in pageContext ? pageContext[${propName}] : someDefaultValue`,
+            '   ```',
+            `See stack track below to find where pageContext[${propName}] is being accessed.`
+        ].join('\n'), { showStackTrace: true, onlyOnce: false });
     }
 }
 const IGNORE_LIST = [

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

@@ -6,6 +6,7 @@ import { getConfigVike } from '../../shared/getConfigVike.js';
 import { isViteCliCall, getViteConfigFromCli } from '../shared/isViteCliCall.js';
 import pc from '@brillout/picocolors';
 import { logErrorHint } from '../../runtime/renderPage/logErrorHint.js';
+import { manifestTempFile } from './buildConfig.js';
 let forceExit = false;
 function autoFullBuild() {
     let config;
@@ -58,10 +59,12 @@ async function triggerFullBuild(config, configVike, bundle) {
         return; // already triggered
     if (isDisabled(configVike))
         return;
-    /* Is this @vitejs/plugin-legacy workaround still needed? Should we re-implement it?
-    // vike.json missing => it isn't a `$ vite build` call (e.g. @vitejs/plugin-legacy calls Vite's build() API) => skip
-    if (!bundle['vike.json']) return
-    */
+    // Workaround for @vitejs/plugin-legacy
+    //  - 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])
+        return;
     const configFromCli = !isViteCliCall() ? null : getViteConfigFromCli();
     const configInline = {
         ...configFromCli,

package/dist/esm/node/plugin/plugins/buildConfig/fixServerAssets.d.ts

@@ -1,7 +1,7 @@
 export { fixServerAssets };
 export { fixServerAssets_isEnabled };
 import { ViteManifest } from '../../../shared/ViteManifest.js';
-import { OutDirs } from '../../utils.js';
+import { ResolvedConfig } from 'vite';
 /**
  * true  => use workaround config.build.ssrEmitAssets
  * false => use workaround extractAssets plugin
@@ -10,4 +10,4 @@ import { OutDirs } from '../../utils.js';
  */
 declare function fixServerAssets_isEnabled(): boolean;
 /** https://github.com/vikejs/vike/issues/1339 */
-declare function fixServerAssets(outDirs: OutDirs): Promise<ViteManifest>;
+declare function fixServerAssets(config: ResolvedConfig): Promise<ViteManifest>;

package/dist/esm/node/plugin/plugins/buildConfig/fixServerAssets.js

@@ -3,9 +3,10 @@ export { fixServerAssets_isEnabled };
 import fs from 'fs/promises';
 import path from 'path';
 import { existsSync } from 'fs';
-import { assert, pLimit, unique } from '../../utils.js';
+import { assert, getOutDirs, pLimit, unique } from '../../utils.js';
 import { isVirtualFileIdPageConfigValuesAll } from '../../../shared/virtual-files/virtualFilePageConfigValuesAll.js';
 import { manifestTempFile } from '../buildConfig.js';
+import { getAssetsDir } from '../../shared/getAssetsDir.js';
 /**
  * true  => use workaround config.build.ssrEmitAssets
  * false => use workaround extractAssets plugin
@@ -18,11 +19,12 @@ function fixServerAssets_isEnabled() {
     return true;
 }
 /** https://github.com/vikejs/vike/issues/1339 */
-async function fixServerAssets(outDirs) {
+async function fixServerAssets(config) {
+    const outDirs = getOutDirs(config);
     const clientManifest = await loadManifest(outDirs.outDirClient);
     const serverManifest = await loadManifest(outDirs.outDirServer);
     const { clientManifestMod, filesToCopy } = addServerAssets(clientManifest, serverManifest);
-    await copyAssets(filesToCopy, outDirs);
+    await copyAssets(filesToCopy, config);
     return clientManifestMod;
 }
 async function loadManifest(outDir) {
@@ -33,11 +35,13 @@ async function loadManifest(outDir) {
     assert(manifest);
     return manifest;
 }
-async function copyAssets(filesToCopy, { outDirClient, outDirServer }) {
-    const assetsDirServer = path.posix.join(outDirServer, 'assets');
+async function copyAssets(filesToCopy, config) {
+    const { outDirClient, outDirServer } = getOutDirs(config);
+    const assetsDir = getAssetsDir(config);
+    const assetsDirServer = path.posix.join(outDirServer, assetsDir);
+    assert(existsSync(assetsDirServer));
     if (!filesToCopy.length)
         return;
-    assert(existsSync(assetsDirServer));
     const concurrencyLimit = pLimit(10);
     await Promise.all(filesToCopy.map((file) => concurrencyLimit(() => fs.cp(path.posix.join(outDirServer, file), path.posix.join(outDirClient, file), {
         recursive: true

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

@@ -24,13 +24,15 @@ function buildConfig() {
     let isServerAssetsFixEnabled;
     let isSsrBuild;
     let outDirs;
+    let config;
     return {
         name: 'vike:buildConfig',
         apply: 'build',
         enforce: 'post',
         configResolved: {
             order: 'post',
-            async handler(config) {
+            async handler(config_) {
+                config = config_;
                 assertNodeEnv();
                 assertRollupInput(config);
                 const entries = await getEntries(config);
@@ -63,24 +65,28 @@ function buildConfig() {
         buildStart() {
             assertNodeEnv();
         },
-        async writeBundle(options, bundle) {
-            if (isSsrBuild) {
-                // Ideally we'd move dist/_temp_manifest.json to dist/server/client-assets.json instead of dist/assets.json
-                //  - But we can't because there is no guarentee whether dist/server/ is generated before or after dist/client/ (generating dist/server/ after dist/client/ erases dist/server/client-assets.json)
-                //  - We'll able to do so once we replace `$ vite build` with `$ vike build`
-                const assetsJsonFilePath = path.posix.join(outDirs.outDirRoot, 'assets.json');
-                const clientManifestFilePath = path.posix.join(outDirs.outDirClient, manifestTempFile);
-                const serverManifestFilePath = path.posix.join(outDirs.outDirServer, manifestTempFile);
-                if (!isServerAssetsFixEnabled) {
-                    await fs.copyFile(clientManifestFilePath, assetsJsonFilePath);
-                }
-                else {
-                    const clientManifestMod = await fixServerAssets(outDirs);
-                    await fs.writeFile(assetsJsonFilePath, JSON.stringify(clientManifestMod, null, 2), 'utf-8');
+        writeBundle: {
+            order: 'post',
+            sequential: true,
+            async handler(options, bundle) {
+                if (isSsrBuild) {
+                    // Ideally we'd move dist/_temp_manifest.json to dist/server/client-assets.json instead of dist/assets.json
+                    //  - But we can't because there is no guarentee whether dist/server/ is generated before or after dist/client/ (generating dist/server/ after dist/client/ erases dist/server/client-assets.json)
+                    //  - We'll able to do so once we replace `$ vite build` with `$ vike build`
+                    const assetsJsonFilePath = path.posix.join(outDirs.outDirRoot, 'assets.json');
+                    const clientManifestFilePath = path.posix.join(outDirs.outDirClient, manifestTempFile);
+                    const serverManifestFilePath = path.posix.join(outDirs.outDirServer, manifestTempFile);
+                    if (!isServerAssetsFixEnabled) {
+                        await fs.copyFile(clientManifestFilePath, assetsJsonFilePath);
+                    }
+                    else {
+                        const clientManifestMod = await fixServerAssets(config);
+                        await fs.writeFile(assetsJsonFilePath, JSON.stringify(clientManifestMod, null, 2), 'utf-8');
+                    }
+                    await fs.rm(clientManifestFilePath);
+                    await fs.rm(serverManifestFilePath);
+                    await set_constant_ASSETS_MAP(options, bundle);
                 }
-                await fs.rm(clientManifestFilePath);
-                await fs.rm(serverManifestFilePath);
-                await set_constant_ASSETS_MAP(options, bundle);
             }
         }
     };

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

@@ -1,5 +1,5 @@
 export { commonConfig };
-import { assert, assertWarning, findFile } from '../utils.js';
+import { assert, assertUsage, assertWarning, findFile } from '../utils.js';
 import { assertRollupInput } from './buildConfig.js';
 import { installRequireShim_setUserRootDir } from '@brillout/require-shim';
 import pc from '@brillout/picocolors';
@@ -9,16 +9,18 @@ import { assertResolveAlias } from './commonConfig/assertResolveAlias.js';
 // @ts-ignore Shimmed by dist-cjs-fixup.js for CJS build.
 const importMetaUrl = import.meta.url;
 const require_ = createRequire(importMetaUrl);
+const pluginName = 'vike:commonConfig-1';
 function commonConfig() {
     return [
         {
-            name: 'vike-commonConfig-1',
+            name: pluginName,
             configResolved(config) {
+                assertSingleInstance(config);
                 installRequireShim_setUserRootDir(config.root);
             }
         },
         {
-            name: 'vike-.commonConfig-2',
+            name: 'vike:commonConfig-2',
             enforce: 'post',
             configResolved: {
                 order: 'post',
@@ -75,3 +77,7 @@ function assertEsm(userViteRoot) {
     dir = pc.dim(dir);
     assertWarning(packageJson.type === 'module', `We recommend setting ${dir}package.json#type to "module", see https://vike.dev/CJS`, { onlyOnce: true });
 }
+function assertSingleInstance(config) {
+    const numberOfInstances = config.plugins.filter((o) => o.name === pluginName).length;
+    assertUsage(numberOfInstances === 1, `Vike's Vite plugin (${pc.cyan("import vike from 'vike/plugin'")}) is being added ${numberOfInstances} times to the list of Vite plugins. Make sure to add it only once instead.`);
+}

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

@@ -4,6 +4,7 @@ export { distFileNames };
 //  - Blocker: https://github.com/rollup/rollup/issues/4724
 import { assertPosixPath, assert, assertUsage } from '../utils.js';
 import path from 'path';
+import { getAssetsDir } from '../shared/getAssetsDir.js';
 function distFileNames() {
     return {
         name: 'vike:distFileNames',
@@ -163,9 +164,3 @@ function getRollupOutputs(config) {
     }
     return output;
 }
-function getAssetsDir(config) {
-    let { assetsDir } = config.build;
-    assertUsage(assetsDir, `${assetsDir} cannot be an empty string`);
-    assetsDir = assetsDir.split(/\/|\\/).filter(Boolean).join('/');
-    return assetsDir;
-}

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

@@ -40,12 +40,11 @@ function getEntryCode(config, configVike) {
         `  import * as pageFiles from '${virtualFileIdImportUserCodeServer}';`,
         `  {`,
         // We first set the values to a variable because of a Rollup bug, and this workaround doesn't work: https://github.com/vikejs/vike/commit/d5f3a4f7aae5a8bc44192e6cbb2bcb9007be188d
-        `    const clientManifest = ${ASSETS_MAP};`,
+        `    const assetsManifest = ${ASSETS_MAP};`,
         `    const pluginManifest = ${JSON.stringify(vikeManifest, null, 2)};`,
         '    setImportBuildGetters({',
         `      pageFiles: () => pageFiles,`,
-        // TODO: rename clientManifest -> assetManifest
-        `      clientManifest: () => clientManifest,`,
+        `      getAssetsManifest: () => assetsManifest,`,
         // TODO: rename pluginManifest -> vikeManifest
         `      pluginManifest: () => pluginManifest,`,
         '    });',

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig.d.ts

@@ -3,7 +3,7 @@ export { reloadVikeConfig };
 export { vikeConfigDependencies };
 export { isVikeConfigFile };
 export { isV1Design };
-export type { VikeConfig };
+export type { VikeConfigObject };
 export type { InterfaceValueFile };
 import type { PageConfigGlobalBuildTime, PageConfigBuildTime, FilePathResolved } from '../../../../../shared/page-configs/PageConfig.js';
 import { type LocationId } from './getVikeConfig/filesystemRouting.js';
@@ -21,13 +21,13 @@ type InterfaceValueFile = InterfaceFileCommons & {
     configName: string;
 };
 type ConfigName = string;
-type VikeConfig = {
+type VikeConfigObject = {
     pageConfigs: PageConfigBuildTime[];
     pageConfigGlobal: PageConfigGlobalBuildTime;
     globalVikeConfig: Record<string, unknown>;
 };
 declare const vikeConfigDependencies: Set<string>;
 declare function reloadVikeConfig(userRootDir: string, outDirRoot: string): void;
-declare function getVikeConfig(config: ResolvedConfig, isDev: boolean, tolerateInvalidConfig?: boolean): Promise<VikeConfig>;
+declare function getVikeConfig(config: ResolvedConfig, isDev: boolean, tolerateInvalidConfig?: boolean): Promise<VikeConfigObject>;
 declare function isV1Design(config: ResolvedConfig, isDev: boolean): Promise<boolean>;
 declare function isVikeConfigFile(filePath: string): boolean;

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig.js

@@ -469,7 +469,8 @@ function warnOverridenConfigValues(interfaceFileWinner, interfaceFilesOverriden,
     interfaceFilesOverriden.forEach((interfaceFileLoser) => {
         const loserFilePath = interfaceFileLoser.filePath.filePathToShowToUser;
         const winnerFilePath = interfaceFileWinner.filePath.filePathToShowToUser;
-        assertWarning(false, `Config ${configName} defined at ${loserFilePath} is always overwritten by ${configName} defined at ${winnerFilePath}, remove the superfluous ${configName} value defined at ${interfaceFileLoser}`, { onlyOnce: false });
+        const confName = pc.cyan(configName);
+        assertWarning(false, `The value of the config ${confName} defined at ${loserFilePath} is always overwritten by the value defined at ${winnerFilePath}, remove the superfluous value defined at ${loserFilePath}`, { onlyOnce: true });
     });
 }
 function isInterfaceFileUserLand(interfaceFile) {
@@ -510,6 +511,7 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
             valueIsFilePath: true,
             configEnv,
             valueIsImportedAtRuntime: true,
+            valueIsDefinedByValueFile: false,
             definedAt
         };
         return configValueSource;
@@ -525,6 +527,7 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
                 locationId,
                 configEnv,
                 valueIsImportedAtRuntime: true,
+                valueIsDefinedByValueFile: false,
                 definedAt: import_
             };
             // Load fake import
@@ -549,6 +552,7 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
             value: configValue,
             configEnv,
             valueIsImportedAtRuntime: false,
+            valueIsDefinedByValueFile: false,
             definedAt: definedAtConfigFile
         };
         return configValueSource;
@@ -561,6 +565,7 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
             locationId,
             configEnv,
             valueIsImportedAtRuntime: !valueAlreadyLoaded,
+            valueIsDefinedByValueFile: true,
             definedAt: {
                 ...interfaceFile.filePath,
                 fileExportPathToShowToUser: configName === interfaceFile.configName

package/dist/esm/node/plugin/shared/getAssetsDir.d.ts

@@ -0,0 +1,3 @@
+export { getAssetsDir };
+import type { ResolvedConfig } from 'vite';
+declare function getAssetsDir(config: ResolvedConfig): string;

package/dist/esm/node/plugin/shared/getAssetsDir.js

@@ -0,0 +1,8 @@
+export { getAssetsDir };
+import { assertUsage } from '../utils.js';
+function getAssetsDir(config) {
+    let { assetsDir } = config.build;
+    assertUsage(assetsDir, `${assetsDir} cannot be an empty string`);
+    assetsDir = assetsDir.split(/\/|\\/).filter(Boolean).join('/');
+    return assetsDir;
+}

package/dist/esm/node/runtime/globalContext/loadImportBuild.d.ts

@@ -2,13 +2,13 @@ export { loadImportBuild };
 export { setImportBuildGetters };
 type BuildGetters = null | {
     pageFiles: () => Promise<Record<string, unknown>>;
-    clientManifest: () => Promise<Record<string, unknown>>;
+    getAssetsManifest: () => Promise<Record<string, unknown>>;
     pluginManifest: () => Promise<Record<string, unknown>>;
 };
 declare function setImportBuildGetters(getters: BuildGetters): void;
 declare function loadImportBuild(outDir?: string): Promise<{
     pageFiles: Record<string, unknown>;
-    clientManifest: Record<string, unknown>;
+    assetsManifest: Record<string, unknown>;
     pluginManifest: Record<string, unknown>;
 }>;
 declare global {

package/dist/esm/node/runtime/globalContext/loadImportBuild.js

@@ -13,11 +13,11 @@ async function loadImportBuild(outDir) {
         await importServerEntry(outDir);
         assert(buildGetters.getters);
     }
-    const [pageFiles, clientManifest, pluginManifest] = await Promise.all([
+    const [pageFiles, assetsManifest, pluginManifest] = await Promise.all([
         buildGetters.getters.pageFiles(),
-        buildGetters.getters.clientManifest(),
+        buildGetters.getters.getAssetsManifest(),
         buildGetters.getters.pluginManifest()
     ]);
-    const buildEntries = { pageFiles, clientManifest, pluginManifest };
+    const buildEntries = { pageFiles, assetsManifest, pluginManifest };
     return buildEntries;
 }

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

@@ -1,3 +1,5 @@
+export { getGlobalContextSync };
+export { getGlobalContextAsync };
 export { initGlobalContext };
 export { getGlobalContext };
 export { getViteDevServer };
@@ -10,6 +12,9 @@ import type { ResolvedConfig, ViteDevServer } from 'vite';
 import { PluginManifest } from '../shared/assertPluginManifest.js';
 import type { ConfigVikeResolved } from '../../shared/ConfigVike.js';
 import { type RuntimeManifest } from '../shared/assertRuntimeManifest.js';
+type GlobalContextPublic = {
+    assetsManifest: null | ViteManifest;
+};
 type GlobalContext = {
     baseServer: string;
     baseAssets: null | string;
@@ -22,11 +27,11 @@ type GlobalContext = {
     isPrerendering: false;
     viteConfig: ResolvedConfig;
     viteDevServer: ViteDevServer;
-    clientManifest: null;
+    assetsManifest: null;
     pluginManifest: null;
 } | ({
     isProduction: true;
-    clientManifest: ViteManifest;
+    assetsManifest: ViteManifest;
     pluginManifest: PluginManifest;
     viteDevServer: null;
 } & ({
@@ -37,6 +42,10 @@ type GlobalContext = {
     viteConfig: ResolvedConfig;
 })));
 declare function getGlobalContext(): GlobalContext;
+/** @experimental https://vike.dev/getGlobalContext */
+declare function getGlobalContextSync(): GlobalContextPublic;
+/** @experimental https://vike.dev/getGlobalContext */
+declare function getGlobalContextAsync(): Promise<GlobalContextPublic>;
 declare function setGlobalContext_viteDevServer(viteDevServer: ViteDevServer): void;
 declare function getViteDevServer(): ViteDevServer | null;
 declare function setGlobalContext_prerender(viteConfig: ResolvedConfig): void;