vike 0.4.219 → 0.4.220-commit-9a798ce

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

@@ -2,8 +2,12 @@ export { setScrollPosition };
 export { autoSaveScrollPosition };
 export { scrollToHashOrTop };
 import { assert, onPageHide, sleep, throttle } from './utils.js';
-import { saveScrollPosition } from './history.js';
-function setScrollPosition(scrollTarget) {
+import { replaceHistoryStateOriginal, saveScrollPosition } from './history.js';
+function setScrollPosition(scrollTarget, url) {
+    if (!scrollTarget && url && hasTextFragment(url)) {
+        scrollToTextFragment(url);
+        return;
+    }
     if (scrollTarget && 'x' in scrollTarget) {
         setScroll(scrollTarget);
         return;
@@ -14,6 +18,21 @@ function setScrollPosition(scrollTarget) {
     const hash = getUrlHash();
     scrollToHashOrTop(hash);
 }
+// https://github.com/vikejs/vike/issues/2114
+// https://github.com/WICG/scroll-to-text-fragment/issues/261
+function scrollToTextFragment(url) {
+    const stateOriginal = window.history.state;
+    replaceHistoryStateOriginal(null, url);
+    // We need `history.state===null` before location.replace() so that our 'popstate' handling is correct
+    assert(window.history.state === null);
+    // - Chrome's location.replace() keeps the current state (`history.state===stateOriginal`)
+    // - Firefox's location.replace() replaces the current state with `null` (`history.state===null`)
+    window.location.replace(url);
+    replaceHistoryStateOriginal(stateOriginal, url);
+}
+function hasTextFragment(url) {
+    return url.includes('#') && url.includes(':~:text');
+}
 // Replicates the browser's native behavior
 function scrollToHashOrTop(hash) {
     if (!hash) {
@@ -45,9 +64,14 @@ function scrollToTop() {
  * - Let's remove it and see if users complain?
  */
 function setScroll(scrollPosition) {
-    const scroll = () => window.scrollTo(scrollPosition.x, scrollPosition.y);
-    const done = () => window.scrollX === scrollPosition.x && window.scrollY === scrollPosition.y;
-    // In principle, this `done()` call should force the repaint to be finished. But that doesn't seem to be the case with `Firefox 97.0.1`.
+    const scroll = () => {
+        // `window.scrollTo()` respects the CSS `scroll-behavior: smooth` property
+        window.scrollTo(scrollPosition.x, scrollPosition.y);
+    };
+    const done = () => {
+        return window.scrollX === scrollPosition.x && window.scrollY === scrollPosition.y;
+    };
+    // In principle, this `done()` call should force the repaint to be finished, but that doesn't seem to be the case with `Firefox 97.0.1`.
     if (done())
         return;
     scroll();

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

@@ -21,3 +21,4 @@ export * from '../../utils/onPageVisibilityChange.js';
 export * from '../../utils/augmentType.js';
 export * from '../../utils/PROJECT_VERSION.js';
 export * from '../../utils/genPromise.js';
+export * from '../../utils/catchInfiniteLoop.js';

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

@@ -25,3 +25,4 @@ export * from '../../utils/onPageVisibilityChange.js';
 export * from '../../utils/augmentType.js';
 export * from '../../utils/PROJECT_VERSION.js';
 export * from '../../utils/genPromise.js';
+export * from '../../utils/catchInfiniteLoop.js';

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

@@ -2,9 +2,8 @@ export { normalizeClientSideUrl };
 import { assert, parseUrl } from './utils.js';
 /** Resolves relative URLs */
 function normalizeClientSideUrl(url, options) {
-    // This function doesn't work for `url === '#some-hash'` because `searchOriginal` is `null` even if window.location.href has a search string.
-    // - Thus the resolved absolute URL would be missing the search string.
-    // - It makes sense that `parseUrl()` returns `searchOriginal === null` since there isn't any search string in `url`.
+    // This function doesn't work for `url === '#some-hash'` because `searchOriginal` will be missing: if window.location.href has a search string then it's going to be missing in the returned `urlCurrent` value because `parseUrl(url)` returns `searchOriginal: null` since there isn't any search string in `url`.
+    // - Maybe `const { searchOriginal } = parseUrl(window.location.href)` can be a fix. (Let's check how `normalizeClientSideUrl()` is being used.)
     assert(!url.startsWith('#'));
     const { searchOriginal, hashOriginal, pathname } = parseUrl(url, '/');
     let urlCurrent = `${pathname}${searchOriginal || ''}`;

package/dist/esm/node/api/build.d.ts

@@ -1,13 +1,8 @@
 export { build };
-import { type Rollup } from 'vite';
 import type { APIOptions } from './types.js';
-type RollupOutput = Rollup.RollupOutput | Rollup.RollupOutput[] | Rollup.RollupWatcher;
 /**
  * Programmatically trigger `$ vike build`
  *
  * https://vike.dev/api#build
  */
-declare function build(options?: APIOptions): Promise<{
-    rollupOutputClient: RollupOutput;
-    rollupOutputServer: RollupOutput;
-}>;
+declare function build(options?: APIOptions): Promise<{}>;

package/dist/esm/node/api/build.js

@@ -1,37 +1,32 @@
 export { build };
 import { prepareViteApiCall } from './prepareViteApiCall.js';
 import { build as buildVite } from 'vite';
-import { isPrerenderAutoRunEnabled } from '../prerender/isPrerenderAutoRunEnabled.js';
+import assert from 'assert';
+import { isVikeCli } from '../cli/context.js';
+import { isPrerendering } from '../prerender/context.js';
 /**
  * Programmatically trigger `$ vike build`
  *
  * https://vike.dev/api#build
  */
 async function build(options = {}) {
-    const { viteConfigEnhanced, vikeConfigGlobal } = await prepareViteApiCall(options.viteConfig, 'build');
-    // Build client-side
-    const outputClient = await buildVite(viteConfigEnhanced);
-    // Build server-side
-    const outputServer = await buildVite(setSSR(viteConfigEnhanced));
-    // Pre-render
-    if (isPrerenderAutoRunEnabled(vikeConfigGlobal)) {
-        const { runPrerenderFromAutoRun } = await import('../prerender/runPrerender.js');
-        await runPrerenderFromAutoRun(viteConfigEnhanced);
-    }
+    const { viteConfigEnhanced } = await prepareViteApiCall(options.viteConfig, 'build');
+    // Pass it to autoFullBuild()
+    if (viteConfigEnhanced)
+        viteConfigEnhanced._viteConfigEnhanced = viteConfigEnhanced;
+    // 1. Build client-side
+    // 2. Build server-side
+    //    > See: https://github.com/vikejs/vike/blob/c6c7533a56b3a16fc43ed644fc5c10c02d0ff375/vike/node/plugin/plugins/autoFullBuild.ts#L90
+    // 3. Pre-render (if enabled)
+    //    > See: https://github.com/vikejs/vike/blob/c6c7533a56b3a16fc43ed644fc5c10c02d0ff375/vike/node/plugin/plugins/autoFullBuild.ts#L98
+    //    > We purposely don't start the pre-rendering in this `build()` function but in a Rollup hook instead.
+    //    > Rationale: https://github.com/vikejs/vike/issues/2123
+    await buildVite(viteConfigEnhanced);
+    // When using the Vike CLI with pre-rendering the process is forcefully exited at the end of the buildVite() call above
+    assert(!(isVikeCli() && isPrerendering()));
     return {
-        /* We don't return `viteConfig` because `viteConfigEnhanced` is `InlineConfig` not `ResolvedConfig`
-        viteConfig: viteConfigEnhanced,
-        */
-        rollupOutputClient: outputClient,
-        rollupOutputServer: outputServer
-    };
-}
-function setSSR(viteConfig) {
-    return {
-        ...viteConfig,
-        build: {
-            ...viteConfig?.build,
-            ssr: true
-        }
+    /* We don't return `viteConfig` because `viteConfigEnhanced` is `InlineConfig` not `ResolvedConfig`
+    viteConfig: viteConfigEnhanced,
+    */
     };
 }

package/dist/esm/node/api/context.d.ts

@@ -1,7 +1,7 @@
-export { setOperation };
-export { clearOperation };
 export { isVikeCliOrApi };
+export { setContextApiOperation };
+export { clearContextApiOperation };
 import type { Operation } from './types.js';
 declare function isVikeCliOrApi(): boolean;
-declare function setOperation(operation: Operation): void;
-declare function clearOperation(): void;
+declare function setContextApiOperation(operation: Operation): void;
+declare function clearContextApiOperation(): void;

package/dist/esm/node/api/context.js

@@ -1,12 +1,9 @@
-// export { getOperation }
-export { setOperation };
-export { clearOperation };
 export { isVikeCliOrApi };
+export { setContextApiOperation };
+export { clearContextApiOperation };
 import { assert, getGlobalObject } from './utils.js';
-const globalObject = getGlobalObject('context.ts', {
-    apiOperation: undefined
-});
-function getOperation() {
+const globalObject = getGlobalObject('api/context.ts', {});
+function getApiOperation() {
     assert(globalObject.apiOperation);
     return globalObject.apiOperation;
 }
@@ -14,10 +11,10 @@ function isVikeCliOrApi() {
     // The CLI uses the API
     return !!globalObject.apiOperation;
 }
-function setOperation(operation) {
+function setContextApiOperation(operation) {
     assert(!globalObject.apiOperation);
     globalObject.apiOperation = operation;
 }
-function clearOperation() {
+function clearContextApiOperation() {
     globalObject.apiOperation = undefined;
 }

package/dist/esm/node/api/prepareViteApiCall.d.ts

@@ -6,7 +6,6 @@ import type { InlineConfig, ResolvedConfig } from 'vite';
 import type { Operation } from './types.js';
 declare function prepareViteApiCall(viteConfig: InlineConfig | undefined, operation: Operation): Promise<{
     viteConfigEnhanced: InlineConfig | undefined;
-    vikeConfigGlobal: import("../plugin/plugins/importUserCode/v1-design/getVikeConfig.js").VikeConfigGlobal;
 }>;
 declare function getViteRoot(operation: 'build' | 'dev' | 'preview' | 'prerender'): Promise<string>;
 declare function normalizeViteRoot(root: string): string;

package/dist/esm/node/api/prepareViteApiCall.js

@@ -4,7 +4,7 @@ export { assertViteRoot };
 export { normalizeViteRoot };
 // TODO: enable Vike extensions to add Vite plugins
 import { loadConfigFromFile, mergeConfig, resolveConfig } from 'vite';
-import { clearOperation, setOperation } from './context.js';
+import { clearContextApiOperation, setContextApiOperation } from './context.js';
 import { getVikeConfig2 } from '../plugin/plugins/importUserCode/v1-design/getVikeConfig.js';
 import path from 'path';
 import { assert, assertUsage, getGlobalObject, isObject, toPosixPath } from './utils.js';
@@ -13,31 +13,30 @@ import { clearGlobalContext } from '../runtime/globalContext.js';
 const globalObject = getGlobalObject('prepareViteApiCall.ts', {});
 async function prepareViteApiCall(viteConfig, operation) {
     clear();
-    setOperation(operation);
+    setContextApiOperation(operation);
     return enhanceViteConfig(viteConfig, operation);
 }
 // For subsequent API calls, e.g. calling prerender() after build()
 function clear() {
-    clearOperation();
+    clearContextApiOperation();
     clearGlobalContext();
 }
 async function enhanceViteConfig(viteConfig, operation) {
     const viteInfo = await getInfoFromVite(viteConfig, operation);
     await assertViteRoot2(viteInfo.root, viteInfo.viteConfigEnhanced, operation);
     const vikeConfig = await getVikeConfig2(viteInfo.root, operation === 'dev', viteInfo.vikeVitePluginOptions);
-    const viteConfigEnhanced = addViteSettingsSetByUser(viteInfo.viteConfigEnhanced, vikeConfig);
+    const viteConfigEnhanced = addViteSettingsSetByVikeConfig(viteInfo.viteConfigEnhanced, vikeConfig);
     return {
-        viteConfigEnhanced,
-        vikeConfigGlobal: vikeConfig.vikeConfigGlobal
+        viteConfigEnhanced
     };
 }
-function addViteSettingsSetByUser(viteConfigEnhanced, vikeConfig) {
+function addViteSettingsSetByVikeConfig(viteConfigEnhanced, vikeConfig) {
     const viteConfigs = vikeConfig.global.from.configsCumulative.vite;
     if (!viteConfigs)
         return viteConfigEnhanced;
     viteConfigs.values.forEach((v) => {
         assertUsage(isObject(v.value), `${v.definedAt} should be an object`);
-        viteConfigEnhanced = mergeConfig(v.value, viteConfigEnhanced ?? {});
+        viteConfigEnhanced = mergeConfig(viteConfigEnhanced ?? {}, v.value);
     });
     return viteConfigEnhanced;
 }

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

@@ -1,4 +1,4 @@
 export * from '../../utils/assert.js';
 export * from '../../utils/getGlobalObject.js';
-export * from '../../utils/filesystemPathHandling.js';
+export * from '../../utils/toPosixPath.js';
 export * from '../../utils/isObject.js';

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

@@ -4,5 +4,5 @@ import { onLoad } from './onLoad.js';
 onLoad();
 export * from '../../utils/assert.js';
 export * from '../../utils/getGlobalObject.js';
-export * from '../../utils/filesystemPathHandling.js';
+export * from '../../utils/toPosixPath.js';
 export * from '../../utils/isObject.js';

package/dist/esm/node/cli/context.d.ts

@@ -0,0 +1,5 @@
+export { isVikeCli };
+export { setContextCliCommand };
+import type { Command } from './parseCli.js';
+declare function isVikeCli(): boolean;
+declare function setContextCliCommand(command: Command): void;

package/dist/esm/node/cli/context.js

@@ -0,0 +1,14 @@
+export { isVikeCli };
+export { setContextCliCommand };
+import { assert, getGlobalObject } from './utils.js';
+const globalObject = getGlobalObject('cli/context.ts', {});
+function getCliCommand() {
+    return globalObject.cliCommand;
+}
+function isVikeCli() {
+    return !!globalObject.cliCommand;
+}
+function setContextCliCommand(command) {
+    assert(!globalObject.cliCommand);
+    globalObject.cliCommand = command;
+}

package/dist/esm/node/cli/entry.js

@@ -2,9 +2,11 @@ import { projectInfo } from './utils.js';
 import { dev, build, preview } from '../api/index.js';
 import pc from '@brillout/picocolors';
 import { parseCli } from './parseCli.js';
+import { setContextCliCommand } from './context.js';
 cli();
 async function cli() {
     const { command } = parseCli();
+    setContextCliCommand(command);
     if (command === 'dev') {
         await cmdDev();
     }

package/dist/esm/node/cli/parseCli.d.ts

@@ -1,4 +1,6 @@
 export { parseCli };
+export type { Command };
+type Command = 'dev' | 'build' | 'preview' | 'prerender';
 declare function parseCli(): {
-    command: "build" | "dev" | "preview" | "prerender";
+    command: Command;
 };

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

@@ -1,3 +1,4 @@
 export * from '../../utils/assert.js';
 export * from '../../utils/projectInfo.js';
 export * from '../../utils/includes.js';
+export * from '../../utils/getGlobalObject.js';

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

@@ -5,3 +5,4 @@ onLoad();
 export * from '../../utils/assert.js';
 export * from '../../utils/projectInfo.js';
 export * from '../../utils/includes.js';
+export * from '../../utils/getGlobalObject.js';

package/dist/esm/{utils → node/plugin}/getOutDirs.js

@@ -1,11 +1,11 @@
 export { getOutDirs };
 export { resolveOutDir };
-import { viteIsSSR } from './viteIsSSR.js';
-import { assert, assertUsage } from './assert.js';
-import { pathJoin } from './path-shim.js';
-import { assertPosixPath, toPosixPath } from './filesystemPathHandling.js';
+import { viteIsSSR } from '../../utils/viteIsSSR.js';
+import { assert, assertUsage } from '../../utils/assert.js';
+import { pathJoin } from '../../utils/path-shim.js';
+import { assertPosixPath, toPosixPath } from '../../utils/toPosixPath.js';
 import pc from '@brillout/picocolors';
-import { createDebugger } from './debug.js';
+import { createDebugger } from '../../utils/debug.js';
 const debug = createDebugger('vike:outDir');
 function getOutDirs(config) {
     debug('getOutDirs()', new Error().stack);

package/dist/esm/node/plugin/index.d.ts

@@ -2,6 +2,34 @@ export default plugin;
 export { plugin };
 export { plugin as ssr };
 export type { VikeVitePluginOptions as UserConfig };
+export type { VikeVitePluginOptions };
 export { PROJECT_VERSION as version } from './utils.js';
-import type { VikeVitePluginOptions } from './plugins/importUserCode/v1-design/getVikeConfig.js';
 declare function plugin(vikeVitePluginOptions?: VikeVitePluginOptions): any;
+/** @deprecated Define Vike settings in +config.js instead of vite.config.js */
+type VikeVitePluginOptions = {
+    /** @deprecated Define Vike settings in +config.js instead of vite.config.js */
+    prerender?: boolean | {
+        /** @deprecated Define Vike settings in +config.js instead of vite.config.js */
+        noExtraDir?: boolean;
+        /** @deprecated Define Vike settings in +config.js instead of vite.config.js */
+        parallel?: boolean | number;
+        /** @deprecated Define Vike settings in +config.js instead of vite.config.js */
+        partial?: boolean;
+        /** @deprecated Define Vike settings in +config.js instead of vite.config.js */
+        disableAutoRun?: boolean;
+    };
+    /** @deprecated See https://vike.dev/disableAutoFullBuild */
+    disableAutoFullBuild?: boolean | 'prerender';
+    /** @deprecated Define Vike settings in +config.js instead of vite.config.js */
+    baseServer?: string;
+    /** @deprecated Define Vike settings in +config.js instead of vite.config.js */
+    baseAssets?: string;
+    /** @deprecated It's now `true` by default. You can remove this option. */
+    includeAssetsImportedByServer?: boolean;
+    /** @deprecated Define Vike settings in +config.js instead of vite.config.js */
+    redirects?: Record<string, string>;
+    /** @deprecated Define Vike settings in +config.js instead of vite.config.js */
+    trailingSlash?: boolean;
+    /** @deprecated Define Vike settings in +config.js instead of vite.config.js */
+    disableUrlNormalization?: boolean;
+};

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

@@ -3,8 +3,7 @@ export { plugin };
 // TODO/v1-release: remove
 export { plugin as ssr };
 export { PROJECT_VERSION as version } from './utils.js';
-import { version } from 'vite';
-import { assertUsage, assertVersion, markSetup_vikeVitePlugin } from './utils.js';
+import { assertUsage } from './utils.js';
 import { buildConfig } from './plugins/buildConfig.js';
 import { previewConfig } from './plugins/previewConfig.js';
 import { autoFullBuild } from './plugins/autoFullBuild.js';
@@ -27,8 +26,7 @@ import { setResolveClientEntriesDev } from '../runtime/renderPage/getPageAssets.
 import { resolveClientEntriesDev } from './resolveClientEntriesDev.js';
 import { workaroundCssModuleHmr } from './plugins/workaroundCssModuleHmr.js';
 import { workaroundVite6HmrRegression } from './plugins/workaroundVite6HmrRegression.js';
-markSetup_vikeVitePlugin();
-assertViteVersion();
+// We don't call this in ./onLoad.ts to avoid a cyclic dependency with utils.ts
 setResolveClientEntriesDev(resolveClientEntriesDev);
 // Return as `any` to avoid Plugin type mismatches when there are multiple Vite versions installed
 function plugin(vikeVitePluginOptions = {}) {
@@ -63,10 +61,6 @@ Object.defineProperty(plugin, 'apply', {
         assertUsage(false, `Add ${pc.cyan('vike()')} instead of ${pc.cyan('vike')} to vite.config.js#plugins (i.e. call the function and add the return value instead of adding the function itself)`, { showStackTrace: true });
     }
 });
-// package.json#peerDependencies isn't enough as users can ignore it
-function assertViteVersion() {
-    assertVersion('Vite', version, '5.1.0');
-}
 // Ensures following works: `const vike = require('vike/plugin')` / `import vike from 'vike/plugin'`
 //  - It needs to live at the end of this file, in order to ensure we do it after all assignments to `exports`.
 try {

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

@@ -1,10 +1,15 @@
 export { onLoad };
 import { assertIsNotBrowser } from '../../utils/assertIsNotBrowser.js';
-import { assertIsNotProductionRuntime } from '../../utils/assertSetup.js';
+import { assertIsNotProductionRuntime, markSetup_vikeVitePlugin } from '../../utils/assertSetup.js';
 import { assertNodeVersion } from '../../utils/assertNodeVersion.js';
+import { assertVersion } from '../../utils/assertVersion.js';
+import { version } from 'vite';
 function onLoad() {
+    markSetup_vikeVitePlugin();
     assertIsNotBrowser();
     assertNodeVersion();
-    // Ensure we don't bloat the server runtime with heavy plugin dependencies such as esbuild
+    // package.json#peerDependencies isn't enough as users can ignore it
+    assertVersion('Vite', version, '5.1.0');
+    // Ensure we don't bloat the server runtime with heavy dependencies such Vite and esbuild
     assertIsNotProductionRuntime();
 }

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

@@ -3,26 +3,27 @@ export { autoFullBuild };
 import { build } from 'vite';
 import { assertWarning } from '../utils.js';
 import { runPrerenderFromAutoRun, runPrerender_forceExit } from '../../prerender/runPrerender.js';
-import { isPrerenderAutoRunEnabled } from '../../prerender/isPrerenderAutoRunEnabled.js';
+import { isPrerenderAutoRunEnabled } from '../../prerender/context.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';
 import { getVikeConfig } from './importUserCode/v1-design/getVikeConfig.js';
+import { isVikeCliOrApi } from '../../api/context.js';
+import { isVikeCli } from '../../cli/context.js';
 let forceExit = false;
 function autoFullBuild() {
     let config;
-    let vikeConfigGlobal;
+    let vikeConfig;
     return [
         {
             name: 'vike:autoFullBuild',
             apply: 'build',
             enforce: 'pre',
             async configResolved(config_) {
-                const vikeConfig = await getVikeConfig(config_);
-                vikeConfigGlobal = vikeConfig.vikeConfigGlobal;
+                vikeConfig = await getVikeConfig(config_);
                 config = config_;
-                abortViteBuildSsr(vikeConfigGlobal);
+                abortViteBuildSsr(vikeConfig);
             },
             writeBundle: {
                 /* We can't use this because it breaks Vite's logging. TODO: try again with latest Vite version.
@@ -31,7 +32,7 @@ function autoFullBuild() {
                 */
                 async handler(_options, bundle) {
                     try {
-                        await triggerFullBuild(config, vikeConfigGlobal, bundle);
+                        await triggerFullBuild(config, vikeConfig, bundle);
                     }
                     catch (err) {
                         // Avoid Rollup prefixing the error with [vike:autoFullBuild], for example see https://github.com/vikejs/vike/issues/472#issuecomment-1276274203
@@ -57,10 +58,10 @@ function autoFullBuild() {
         }
     ];
 }
-async function triggerFullBuild(config, vikeConfigGlobal, bundle) {
+async function triggerFullBuild(config, vikeConfig, bundle) {
     if (config.build.ssr)
         return; // already triggered
-    if (isDisabled(vikeConfigGlobal))
+    if (isDisabled(vikeConfig))
         return;
     // Workaround for @vitejs/plugin-legacy
     //  - The legacy plugin triggers its own Rollup build for the client-side.
@@ -69,43 +70,54 @@ async function triggerFullBuild(config, vikeConfigGlobal, bundle) {
     if (!bundle[manifestTempFile])
         return;
     const configFromCli = !isViteCliCall() ? null : getViteConfigFromCli();
-    const configInline = {
-        ...configFromCli,
-        configFile: configFromCli?.configFile || config.configFile,
-        root: config.root,
-        build: {
-            ...configFromCli?.build
-        }
-    };
-    try {
-        await build({
-            ...configInline,
+    let configInline;
+    if (config._viteConfigEnhanced) {
+        configInline = config._viteConfigEnhanced;
+    }
+    else {
+        configInline = {
+            ...configFromCli,
+            configFile: configFromCli?.configFile || config.configFile,
+            root: config.root,
             build: {
-                ...configInline.build,
-                ssr: true
+                ...configFromCli?.build
             }
-        });
+        };
+    }
+    try {
+        await build(setSSR(configInline));
     }
     catch (err) {
         console.error(err);
         logErrorHint(err);
         process.exit(1);
     }
-    if (isPrerenderAutoRunEnabled(vikeConfigGlobal)) {
-        await runPrerenderFromAutoRun(configInline);
-        forceExit = true;
+    if (isPrerenderAutoRunEnabled(vikeConfig)) {
+        const { prerenderContextPublic } = await runPrerenderFromAutoRun(configInline);
+        config.vike.prerenderContext = prerenderContextPublic;
+        forceExit = isVikeCli() || isViteCliCall();
     }
 }
-function abortViteBuildSsr(vikeConfigGlobal) {
-    if (vikeConfigGlobal.disableAutoFullBuild !== true && isViteCliCall() && getViteConfigFromCli()?.build.ssr) {
+function setSSR(configInline) {
+    return {
+        ...configInline,
+        build: {
+            ...configInline.build,
+            ssr: true
+        }
+    };
+}
+function abortViteBuildSsr(vikeConfig) {
+    if (vikeConfig.global.config.disableAutoFullBuild !== true && isViteCliCall() && getViteConfigFromCli()?.build.ssr) {
         assertWarning(false, `The CLI call ${pc.cyan('$ vite build --ssr')} is superfluous since ${pc.cyan('$ vite build')} also builds the server-side. If you want two separate build steps then use https://vike.dev/disableAutoFullBuild or use Vite's ${pc.cyan('build()')} API.`, { onlyOnce: true });
         process.exit(0);
     }
 }
-function isDisabled(vikeConfigGlobal) {
-    const { disableAutoFullBuild } = vikeConfigGlobal;
-    if (disableAutoFullBuild === null || disableAutoFullBuild === 'prerender') {
-        return !isViteCliCall();
+function isDisabled(vikeConfig) {
+    const { disableAutoFullBuild } = vikeConfig.global.config;
+    if (disableAutoFullBuild === undefined || disableAutoFullBuild === 'prerender') {
+        const isViteApi = !isViteCliCall() && !isVikeCliOrApi();
+        return isViteApi;
     }
     else {
         return disableAutoFullBuild;

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

@@ -11,7 +11,7 @@ function baseUrls() {
             const isDev = config._isDev;
             assert(typeof isDev === 'boolean');
             const baseViteOriginal = config.base ?? '/__UNSET__'; // '/__UNSET__' because Vite resolves `_baseViteOriginal: null` to `undefined`
-            basesResolved = resolveBase(baseViteOriginal, config.vike.vikeConfigGlobal.baseServer, config.vike.vikeConfigGlobal.baseAssets);
+            basesResolved = resolveBase(baseViteOriginal, config.vike.global.config.baseServer ?? null, config.vike.global.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;
             process.env.BASE_ASSETS = basesResolved.baseAssets;
@@ -27,7 +27,7 @@ function baseUrls() {
         },
         async configResolved(config) {
             const vikeConfig = await getVikeConfig(config);
-            const basesResolved2 = resolveBaseFromResolvedConfig(vikeConfig.vikeConfigGlobal.baseServer, vikeConfig.vikeConfigGlobal.baseAssets, config);
+            const basesResolved2 = resolveBaseFromResolvedConfig(vikeConfig.global.config.baseServer ?? null, vikeConfig.global.config.baseAssets ?? null, config);
             assert(basesResolved2.baseServer === basesResolved.baseServer);
             assert(basesResolved2.baseAssets === basesResolved.baseAssets);
             /* In dev, Vite seems buggy around setting vite.config.js#base to an absolute URL (e.g. http://localhost:8080/cdn/)

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

@@ -11,7 +11,7 @@ import { createRequire } from 'module';
 import fs from 'fs/promises';
 import path from 'path';
 import { fixServerAssets, fixServerAssets_assertCssCodeSplit, fixServerAssets_assertCssTarget, fixServerAssets_assertCssTarget_populate, fixServerAssets_isEnabled } from './buildConfig/fixServerAssets.js';
-import { set_ASSETS_MAP } from './buildEntry/index.js';
+import { set_ASSETS_MANIFEST } from './buildEntry/index.js';
 import { prependEntriesDir } from '../../shared/prependEntriesDir.js';
 import { getFilePathResolved } from '../shared/getFilePath.js';
 import { getConfigValueBuildTime } from '../../../shared/page-configs/getConfigValueBuildTime.js';
@@ -79,7 +79,7 @@ function buildConfig() {
             name: 'vike:buildConfig:pre',
             apply: 'build',
             // Make sure other writeBundle() hooks are called after this writeBundle() hook.
-            //  - set_ASSETS_MAP() needs to be called before dist/server/ code is executed.
+            //  - set_ASSETS_MANIFEST() needs to be called before dist/server/ code is executed.
             //    - For example, the writeBundle() hook of vite-plugin-vercel needs to be called after this writeBundle() hook, otherwise: https://github.com/vikejs/vike/issues/1527
             enforce: 'pre',
             writeBundle: {
@@ -102,7 +102,7 @@ function buildConfig() {
                         }
                         await fs.rm(clientManifestFilePath);
                         await fs.rm(serverManifestFilePath);
-                        await set_ASSETS_MAP(options, bundle);
+                        await set_ASSETS_MANIFEST(options, bundle);
                     }
                 }
             }
@@ -112,7 +112,10 @@ function buildConfig() {
 async function getEntries(config) {
     const vikeConfig = await getVikeConfig(config);
     const { pageConfigs } = vikeConfig;
-    const pageFileEntries = await getPageFileEntries(config, vikeConfig.vikeConfigGlobal.includeAssetsImportedByServer); // TODO/v1-release: remove
+    // TODO/v1-release: remove
+    const pageFileEntries = await getPageFileEntries(config, 
+    // TODO/now: add meta.default
+    vikeConfig.global.config.includeAssetsImportedByServer ?? true);
     assertUsage(Object.keys(pageFileEntries).length !== 0 || pageConfigs.length !== 0, 'At least one page should be defined, see https://vike.dev/add');
     if (viteIsSSR(config)) {
         const pageEntries = getPageEntries(pageConfigs);

package/dist/esm/node/plugin/plugins/buildEntry/index.d.ts

@@ -1,8 +1,8 @@
 export { buildEntry };
-export { set_ASSETS_MAP };
+export { set_ASSETS_MANIFEST };
 import type { Plugin, Rollup } from 'vite';
 type Bundle = Rollup.OutputBundle;
 type Options = Rollup.NormalizedOutputOptions;
 declare function buildEntry(): Plugin[];
-/** Set the value of the ASSETS_MAP constant inside dist/server/entry.js (or dist/server/index.js) */
-declare function set_ASSETS_MAP(options: Options, bundle: Bundle): Promise<void>;
+/** Set the value of the ASSETS_MANIFEST constant inside dist/server/entry.js (or dist/server/index.js) */
+declare function set_ASSETS_MANIFEST(options: Options, bundle: Bundle): Promise<void>;