vike 0.4.215 → 0.4.217-commit-99ea561

package/dist/cjs/shared/page-configs/getConfigValueBuildTime.js

@@ -2,9 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getConfigValueBuildTime = getConfigValueBuildTime;
 const utils_js_1 = require("../utils.js");
-const assertIsNotProductionRuntime_js_1 = require("../../utils/assertIsNotProductionRuntime.js");
+const assertSetup_js_1 = require("../../utils/assertSetup.js");
 const getConfigValueTyped_js_1 = require("./getConfigValueTyped.js");
-(0, assertIsNotProductionRuntime_js_1.assertIsNotProductionRuntime)();
+(0, assertSetup_js_1.assertIsNotProductionRuntime)();
 function getConfigValueBuildTime(pageConfig, configName, type) {
     const configValue = getConfigValue(pageConfig, configName);
     if (!configValue)

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

@@ -4,7 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.serializeConfigValues = serializeConfigValues;
-const assertIsNotProductionRuntime_js_1 = require("../../../utils/assertIsNotProductionRuntime.js");
+const assertSetup_js_1 = require("../../../utils/assertSetup.js");
 const utils_js_1 = require("../../../node/plugin/utils.js");
 const addImportStatement_js_1 = require("../../../node/plugin/plugins/importUserCode/addImportStatement.js");
 const transformPointerImports_js_1 = require("../../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/transformPointerImports.js");
@@ -16,7 +16,7 @@ const REPLACE_ME_AFTER = '__VIKE__REPLACE_ME_AFTER__';
 // This file is never loaded on the client-side but we save it under the vike/shared/ directory in order to collocate it with parsePageConfigs()
 // - vike/shared/page-configs/serialize/parsePageConfigs.ts
 // - parsePageConfigs() is loaded on both the client- and server-side.
-(0, assertIsNotProductionRuntime_js_1.assertIsNotProductionRuntime)();
+(0, assertSetup_js_1.assertIsNotProductionRuntime)();
 function serializeConfigValues(pageConfig, importStatements, isEnvMatch, { isEager }, tabspace) {
     const lines = [];
     tabspace += '  ';

package/dist/cjs/utils/PROJECT_VERSION.js

@@ -2,4 +2,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PROJECT_VERSION = void 0;
 // Automatically updated by @brillout/release-me
-exports.PROJECT_VERSION = '0.4.215';
+exports.PROJECT_VERSION = '0.4.217-commit-99ea561';

package/dist/cjs/utils/assertSetup.js

@@ -0,0 +1,135 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertIsNotProductionRuntime = assertIsNotProductionRuntime;
+exports.onSetupRuntime = onSetupRuntime;
+exports.onSetupBuild = onSetupBuild;
+exports.onSetupPrerender = onSetupPrerender;
+exports.setNodeEnvProduction = setNodeEnvProduction;
+exports.markSetup_viteDevServer = markSetup_viteDevServer;
+exports.markSetup_vitePreviewServer = markSetup_vitePreviewServer;
+exports.markSetup_vikeVitePlugin = markSetup_vikeVitePlugin;
+exports.markSetup_isViteDev = markSetup_isViteDev;
+exports.markSetup_isPrerendering = markSetup_isPrerendering;
+const assert_js_1 = require("./assert.js");
+const assertIsNotBrowser_js_1 = require("./assertIsNotBrowser.js");
+const debug_js_1 = require("./debug.js");
+const getGlobalObject_js_1 = require("./getGlobalObject.js");
+const isVitest_js_1 = require("./isVitest.js");
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+(0, assertIsNotBrowser_js_1.assertIsNotBrowser)();
+const debug = (0, debug_js_1.createDebugger)('vike:setup');
+const setup = (0, getGlobalObject_js_1.getGlobalObject)('utils/assertIsNotProductionRuntime.ts', {});
+// Called by Vike modules that want to ensure that they aren't loaded by the server runtime in production
+function assertIsNotProductionRuntime() {
+    if (debug.isActivated)
+        debug('assertIsNotProductionRuntime()', new Error().stack);
+    setup.shouldNotBeProduction = true;
+}
+function onSetupRuntime() {
+    if (debug.isActivated)
+        debug('assertSetup()', new Error().stack);
+    if (isTest())
+        return;
+    if (!isViteLoaded()) {
+        // TODO: make it assertUsage() again once https://github.com/vikejs/vike/issues/1528 is implemented.
+        (0, assert_js_1.assertWarning)(!isNodeEnvDev(), `The ${getEnvDescription()}, which seems contradictory because the environment seems to be a production environment (Vite isn't loaded), see https://vike.dev/NODE_ENV`, { onlyOnce: true });
+        (0, assert_js_1.assertUsage)(!setup.vikeVitePlugin, "Loading Vike's Vite plugin (the vike/plugin module) is prohibited in production.");
+        // This assert() one of the main goal of this file: it ensures assertIsNotProductionRuntime()
+        (0, assert_js_1.assert)(!setup.shouldNotBeProduction);
+    }
+    else {
+        // TODO: make it assertUsage() again once https://github.com/vikejs/vike/issues/1528 is implemented.
+        (0, assert_js_1.assertWarning)(isNodeEnvDev() || setup.vitePreviewServer || setup.isPrerendering, `The ${getEnvDescription()}, but Vite is loaded which is prohibited in production, see https://vike.dev/NODE_ENV`, { onlyOnce: true });
+        // These two assert() calls aren't that interesting
+        (0, assert_js_1.assert)(setup.vikeVitePlugin);
+        (0, assert_js_1.assert)(setup.shouldNotBeProduction);
+    }
+}
+// Ensure NODE_ENV is 'production' when building.
+// - Used by both Vue and React for bundling minified version:
+//   - Vue: https://github.com/vuejs/core/blob/f66a75ea75c8aece065b61e2126b4c5b2338aa6e/packages/vue/index.js
+//   - React: https://github.com/facebook/react/blob/01ab35a9a731dec69995fbd28f3ac7eaad11e183/packages/react/npm/index.js
+// - Required for React: setting NODE_ENV to a value other than 'production' triggers an error: https://github.com/vikejs/vike/issues/1469#issuecomment-1969301797
+// - Not required for Vue: when building the app, NODE_ENV can be set to a value other than 'production', e.g. 'development'.
+function onSetupBuild() {
+    assertUsageNodeEnvIsNotDev('building');
+    /* Not needed: Vite already sets `process.env.NODE_ENV = 'production'`
+    setNodeEnvProduction()
+    */
+}
+function onSetupPrerender() {
+    markSetup_isPrerendering();
+    if (getNodeEnvValue())
+        assertUsageNodeEnvIsNotDev('pre-rendering');
+    setNodeEnvProduction();
+}
+function isViteLoaded() {
+    // Do we need setup.viteDevServer or setup.vitePreviewServer ?
+    return setup.viteDevServer || setup.vitePreviewServer || setup.isViteDev !== undefined;
+}
+function isTest() {
+    return (0, isVitest_js_1.isVitest)() || getNodeEnvValue() === 'test';
+}
+// Called by Vite hook configureServer()
+function markSetup_viteDevServer() {
+    if (debug.isActivated)
+        debug('markSetup_viteDevServer()', new Error().stack);
+    setup.viteDevServer = true;
+}
+// Called by Vite hook configurePreviewServer()
+function markSetup_vitePreviewServer() {
+    if (debug.isActivated)
+        debug('markSetup_vitePreviewServer()', new Error().stack);
+    setup.vitePreviewServer = true;
+}
+// Called by ../node/plugin/index.ts
+function markSetup_vikeVitePlugin() {
+    if (debug.isActivated)
+        debug('markSetup_vikeVitePlugin()', new Error().stack);
+    setup.vikeVitePlugin = true;
+}
+// Whether Vite is loaded and whether it's in dev mode (the value returned by `isDevCheck()`)
+function markSetup_isViteDev(isViteDev) {
+    if (debug.isActivated)
+        debug('markSetup_isViteDev()', new Error().stack);
+    setup.isViteDev = isViteDev;
+}
+// Called by ../node/prerender/runPrerender.ts
+function markSetup_isPrerendering() {
+    if (debug.isActivated)
+        debug('markSetup_isPrerendering()', new Error().stack);
+    setup.isPrerendering = true;
+}
+function assertUsageNodeEnvIsNotDev(operation) {
+    if (!isNodeEnvDev())
+        return;
+    // TODO: make it assertUsage() again once https://github.com/vikejs/vike/issues/1528 is implemented.
+    (0, assert_js_1.assertWarning)(false, `The ${getEnvDescription()} which is forbidden upon ${operation}, see https://vike.dev/NODE_ENV`, { onlyOnce: true });
+}
+function getEnvDescription() {
+    const nodeEnv = getNodeEnvValue();
+    const isDev = isNodeEnvDev();
+    const envType = `${(isDev ? 'development' : 'production')} environment`;
+    const nodeEnvDesc = `environment is set to be a ${picocolors_1.default.bold(envType)} by ${picocolors_1.default.cyan(`process.env.NODE_ENV===${JSON.stringify(nodeEnv)}`)}`;
+    return nodeEnvDesc;
+}
+function isNodeEnvDev() {
+    const nodeEnv = getNodeEnvValue();
+    // That's quite strict, let's see if some user complains
+    return !nodeEnv || ['development', 'dev'].includes(nodeEnv);
+}
+function getNodeEnvValue() {
+    if (typeof process === 'undefined')
+        return null;
+    return process.env.NODE_ENV?.toLowerCase();
+}
+function setNodeEnvProduction() {
+    // The statement `process.env['NODE_ENV'] = 'production'` chokes webpack v4
+    const proc = process;
+    const { env } = proc;
+    env.NODE_ENV = 'production';
+    (0, assert_js_1.assert)(getNodeEnvValue() === 'production');
+}

package/dist/cjs/utils/isDocker.js

@@ -5,8 +5,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isDocker = isDocker;
 const node_fs_1 = __importDefault(require("node:fs"));
-const assertIsNotProductionRuntime_js_1 = require("./assertIsNotProductionRuntime.js");
-(0, assertIsNotProductionRuntime_js_1.assertIsNotProductionRuntime)();
+const assertSetup_js_1 = require("./assertSetup.js");
+(0, assertSetup_js_1.assertIsNotProductionRuntime)();
 function isDocker() {
     return hasContainerEnv() || isDockerContainer();
 }

package/dist/cjs/utils/requireResolve.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.requireResolve = requireResolve;
 const assert_js_1 = require("./assert.js");
 const assertIsNotBrowser_js_1 = require("./assertIsNotBrowser.js");
-const assertIsNotProductionRuntime_js_1 = require("./assertIsNotProductionRuntime.js");
+const assertSetup_js_1 = require("./assertSetup.js");
 const filesystemPathHandling_js_1 = require("./filesystemPathHandling.js");
 const isScriptFile_js_1 = require("./isScriptFile.js");
 const module_1 = require("module");
@@ -11,7 +11,7 @@ const module_1 = require("module");
 const importMetaUrl = `file://${__filename}`;
 const require_ = (0, module_1.createRequire)(importMetaUrl);
 (0, assertIsNotBrowser_js_1.assertIsNotBrowser)();
-(0, assertIsNotProductionRuntime_js_1.assertIsNotProductionRuntime)();
+(0, assertSetup_js_1.assertIsNotProductionRuntime)();
 // We still can't use import.meta.resolve() as of 23.1.0 (November 2024) because `parent` argument requires an experimental flag.
 // - https://stackoverflow.com/questions/54977743/do-require-resolve-for-es-modules#comment139581675_62272600
 function requireResolve(importPath, cwd) {

package/dist/esm/__internal/index.js

@@ -5,7 +5,7 @@ export { getMiddlewares };
 import { route as routeInternal } from '../shared/route/index.js';
 import { getPageFilesAll } from '../shared/getPageFiles.js';
 import { getGlobalContext, initGlobalContext_getGlobalContextAsync } from '../node/runtime/globalContext.js';
-import { handleNodeEnv_vitePluginVercel } from '../utils/assertNodeEnv.js';
+import { setNodeEnvProduction } from '../utils/assertSetup.js';
 import { getRenderContext } from '../node/runtime/renderPage/renderPageAlreadyRouted.js';
 /**
  * Used by {@link https://github.com/magne4000/vite-plugin-vercel|vite-plugin-vercel}
@@ -14,7 +14,7 @@ import { getRenderContext } from '../node/runtime/renderPage/renderPageAlreadyRo
  * @param config
  */
 async function getPagesAndRoutes() {
-    handleNodeEnv_vitePluginVercel();
+    setNodeEnvProduction();
     const renderContext = await getRenderContext();
     const { 
     //

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

@@ -2,6 +2,11 @@ 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;

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

@@ -1,14 +1,21 @@
 export { build };
-import { prepareApiCall } from './prepareApiCall.js';
+import { prepareViteApiCall } from './prepareViteApiCall.js';
 import { build as buildVite } from 'vite';
+/**
+ * Programmatically trigger `$ vike build`
+ *
+ * https://vike.dev/api#build
+ */
 async function build(options = {}) {
-    const { viteConfigEnhanced, configVike } = await prepareApiCall(options.viteConfig, 'build');
+    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 (configVike.prerender && !configVike.prerender.disableAutoRun && configVike.disableAutoFullBuild !== 'prerender') {
+    if (vikeConfigGlobal.prerender &&
+        !vikeConfigGlobal.prerender.disableAutoRun &&
+        vikeConfigGlobal.disableAutoFullBuild !== 'prerender') {
         const { runPrerenderFromAutoRun } = await import('../prerender/runPrerender.js');
         await runPrerenderFromAutoRun(viteConfigEnhanced, true);
     }

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

@@ -1,17 +1,19 @@
 export { isVikeCliOrApi };
 // export { getOperation }
 export { setOperation as setOperation };
-import { assert } from './utils.js';
-let apiOperation;
+import { assert, getGlobalObject } from './utils.js';
+const globalObject = getGlobalObject('context.ts', {
+    apiOperation: undefined
+});
 function getOperation() {
-    assert(apiOperation);
-    return apiOperation;
+    assert(globalObject.apiOperation);
+    return globalObject.apiOperation;
 }
 function isVikeCliOrApi() {
     // The CLI uses the API
-    return !!apiOperation;
+    return !!globalObject.apiOperation;
 }
 function setOperation(operation) {
-    assert(!apiOperation);
-    apiOperation = operation;
+    assert(!globalObject.apiOperation);
+    globalObject.apiOperation = operation;
 }

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

@@ -1,6 +1,11 @@
 export { dev };
 import { type ResolvedConfig, type ViteDevServer } from 'vite';
 import type { APIOptions } from './types.js';
+/**
+ * Programmatically trigger `$ vike dev`
+ *
+ * https://vike.dev/api#dev
+ */
 declare function dev(options?: APIOptions): Promise<{
     viteServer: ViteDevServer;
     viteConfig: ResolvedConfig;

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

@@ -1,8 +1,13 @@
 export { dev };
-import { prepareApiCall } from './prepareApiCall.js';
+import { prepareViteApiCall } from './prepareViteApiCall.js';
 import { createServer } from 'vite';
+/**
+ * Programmatically trigger `$ vike dev`
+ *
+ * https://vike.dev/api#dev
+ */
 async function dev(options = {}) {
-    const { viteConfigEnhanced } = await prepareApiCall(options.viteConfig, 'dev');
+    const { viteConfigEnhanced } = await prepareViteApiCall(options.viteConfig, 'dev');
     const server = await createServer(viteConfigEnhanced);
     return {
         viteServer: server,

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

@@ -0,0 +1,7 @@
+export { prepareViteApiCall };
+import type { InlineConfig } from 'vite';
+import type { Operation } from './types.js';
+declare function prepareViteApiCall(viteConfig: InlineConfig | undefined, operation: Operation): Promise<{
+    viteConfigEnhanced: InlineConfig;
+    vikeConfigGlobal: import("../plugin/plugins/importUserCode/v1-design/getVikeConfig/resolveVikeConfigGlobal.js").VikeConfigGlobal;
+}>;

package/dist/esm/node/api/{prepareApiCall.js → prepareViteApiCall.js}

@@ -1,9 +1,9 @@
-export { prepareApiCall };
+export { prepareViteApiCall };
 import { resolveConfig } from 'vite';
-import { getConfigVike } from '../shared/getConfigVike.js';
 import { pluginName } from '../plugin/plugins/commonConfig/pluginName.js';
 import { setOperation } from './context.js';
-async function prepareApiCall(viteConfig = {}, operation) {
+import { getVikeConfig2 } from '../plugin/plugins/importUserCode/v1-design/getVikeConfig.js';
+async function prepareViteApiCall(viteConfig = {}, operation) {
     setOperation(operation);
     return enhanceViteConfig(viteConfig, operation);
 }
@@ -20,13 +20,23 @@ async function enhanceViteConfig(viteConfig = {}, operation) {
         };
         viteConfigResolved = await resolveViteConfig(viteConfigEnhanced, operation);
     }
-    const configVike = await getConfigVike(viteConfigResolved);
+    // TODO: use loadConfigFromFile() instead of viteConfigResolved
+    const { vikeConfigGlobal } = await getVikeConfig2(viteConfigResolved.root, operation === 'dev', viteConfigResolved._vikeVitePluginOptions);
     // TODO: enable Vike extensions to add Vite plugins
     return {
         viteConfigEnhanced,
-        configVike
+        vikeConfigGlobal
     };
 }
 async function resolveViteConfig(viteConfig, operation) {
-    return await resolveConfig(viteConfig, operation === 'build' || operation === 'prerender' ? 'build' : 'serve', 'custom', operation === 'dev' ? 'development' : 'production', operation === 'preview');
+    const args = getResolveConfigArgs(viteConfig, operation);
+    return await resolveConfig(...args);
+}
+function getResolveConfigArgs(viteConfig, operation) {
+    const inlineConfig = viteConfig;
+    const command = operation === 'build' || operation === 'prerender' ? 'build' : 'serve';
+    const defaultMode = operation === 'dev' ? 'development' : 'production';
+    const defaultNodeEnv = defaultMode;
+    const isPreview = operation === 'preview';
+    return [inlineConfig, command, defaultMode, defaultNodeEnv, isPreview];
 }

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

@@ -1,6 +1,11 @@
 export { prerender };
 import { type PrerenderOptions } from '../prerender/runPrerender.js';
 import type { ResolvedConfig } from 'vite';
+/**
+ * Programmatically trigger `$ vike prerender`
+ *
+ * https://vike.dev/api#prerender
+ */
 declare function prerender(options?: PrerenderOptions): Promise<{
     viteConfig: ResolvedConfig;
 }>;

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

@@ -1,8 +1,13 @@
 export { prerender };
 import { runPrerenderFromAPI } from '../prerender/runPrerender.js';
-import { prepareApiCall } from './prepareApiCall.js';
+import { prepareViteApiCall } from './prepareViteApiCall.js';
+/**
+ * Programmatically trigger `$ vike prerender`
+ *
+ * https://vike.dev/api#prerender
+ */
 async function prerender(options = {}) {
-    const { viteConfigEnhanced } = await prepareApiCall(options.viteConfig, 'prerender');
+    const { viteConfigEnhanced } = await prepareViteApiCall(options.viteConfig, 'prerender');
     options.viteConfig = viteConfigEnhanced;
     const { viteConfig } = await runPrerenderFromAPI(options);
     return {

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

@@ -1,6 +1,11 @@
 export { preview };
 import { type ResolvedConfig, type PreviewServer } from 'vite';
 import type { APIOptions } from './types.js';
+/**
+ * Programmatically trigger `$ vike preview`
+ *
+ * https://vike.dev/api#preview
+ */
 declare function preview(options?: APIOptions): Promise<{
     viteServer: PreviewServer;
     viteConfig: ResolvedConfig;

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

@@ -1,8 +1,13 @@
 export { preview };
-import { prepareApiCall } from './prepareApiCall.js';
+import { prepareViteApiCall } from './prepareViteApiCall.js';
 import { preview as previewVite } from 'vite';
+/**
+ * Programmatically trigger `$ vike preview`
+ *
+ * https://vike.dev/api#preview
+ */
 async function preview(options = {}) {
-    const { viteConfigEnhanced } = await prepareApiCall(options.viteConfig, 'preview');
+    const { viteConfigEnhanced } = await prepareViteApiCall(options.viteConfig, 'preview');
     const server = await previewVite(viteConfigEnhanced);
     return {
         viteServer: server,

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

@@ -1 +1,2 @@
 export * from '../../utils/assert.js';
+export * from '../../utils/getGlobalObject.js';

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

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

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

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

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

@@ -1,7 +1,7 @@
 export default plugin;
 export { plugin };
 export { plugin as ssr };
-export type { ConfigVikeUserProvided as UserConfig };
+export type { VikeVitePluginOptions as UserConfig };
 export { PROJECT_VERSION as version } from './utils.js';
-import type { ConfigVikeUserProvided } from '../../shared/ConfigVike.js';
-declare function plugin(vikeConfig?: ConfigVikeUserProvided): any;
+import type { VikeVitePluginOptions } from './plugins/importUserCode/v1-design/getVikeConfig/resolveVikeConfigGlobal.js';
+declare function plugin(vikeVitePluginOptions?: VikeVitePluginOptions): any;

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

@@ -4,7 +4,7 @@ export { plugin };
 export { plugin as ssr };
 export { PROJECT_VERSION as version } from './utils.js';
 import { version } from 'vite';
-import { assertNodeEnv_onVikePluginLoad, assertUsage, assertVersion, markEnvAsVikePluginLoaded } from './utils.js';
+import { assertUsage, assertVersion, markSetup_vikeVitePlugin } from './utils.js';
 import { buildConfig } from './plugins/buildConfig.js';
 import { previewConfig } from './plugins/previewConfig.js';
 import { autoFullBuild } from './plugins/autoFullBuild.js';
@@ -12,7 +12,6 @@ import { devConfig } from './plugins/devConfig/index.js';
 import { packageJsonFile } from './plugins/packageJsonFile.js';
 import { removeRequireHookPlugin } from './plugins/removeRequireHookPlugin.js';
 import { importUserCode } from './plugins/importUserCode/index.js';
-import { resolveVikeConfig } from './plugins/config/index.js';
 import { distFileNames } from './plugins/distFileNames.js';
 import { extractAssetsPlugin } from './plugins/extractAssetsPlugin.js';
 import { extractExportNamesPlugin } from './plugins/extractExportNamesPlugin.js';
@@ -28,15 +27,13 @@ import { setResolveClientEntriesDev } from '../runtime/renderPage/getPageAssets.
 import { resolveClientEntriesDev } from './resolveClientEntriesDev.js';
 import { workaroundCssModuleHmr } from './plugins/workaroundCssModuleHmr.js';
 import { vite6HmrRegressionWorkaround } from './plugins/vite6HmrRegressionWorkaround.js';
-assertNodeEnv_onVikePluginLoad();
-markEnvAsVikePluginLoaded();
+markSetup_vikeVitePlugin();
 assertViteVersion();
 setResolveClientEntriesDev(resolveClientEntriesDev);
 // Return as `any` to avoid Plugin type mismatches when there are multiple Vite versions installed
-function plugin(vikeConfig) {
+function plugin(vikeVitePluginOptions) {
     const plugins = [
-        resolveVikeConfig(vikeConfig), // The configResolved() hook of resolveVikeConfig() should be the first called
-        ...commonConfig(),
+        ...commonConfig(vikeVitePluginOptions),
         importUserCode(),
         ...devConfig(),
         ...buildConfig(),
@@ -48,9 +45,9 @@ function plugin(vikeConfig) {
         ...extractAssetsPlugin(),
         extractExportNamesPlugin(),
         suppressRollupWarning(),
-        setGlobalContext(),
+        ...setGlobalContext(),
         ...importBuild(),
-        baseUrls(vikeConfig),
+        baseUrls(vikeVitePluginOptions),
         envVarsPlugin(),
         fileEnv(),
         workaroundCssModuleHmr(),

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

@@ -1,6 +1,6 @@
 export { onLoad };
 import { assertIsNotBrowser } from '../../utils/assertIsNotBrowser.js';
-import { assertIsNotProductionRuntime } from '../../utils/assertIsNotProductionRuntime.js';
+import { assertIsNotProductionRuntime } from '../../utils/assertSetup.js';
 import { assertNodeVersion } from '../../utils/assertNodeVersion.js';
 function onLoad() {
     assertIsNotBrowser();

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

@@ -3,24 +3,25 @@ export { autoFullBuild };
 import { build } from 'vite';
 import { assertWarning } from '../utils.js';
 import { runPrerenderFromAutoRun, runPrerender_forceExit } from '../../prerender/runPrerender.js';
-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';
+import { getVikeConfig } from './importUserCode/v1-design/getVikeConfig.js';
 let forceExit = false;
 function autoFullBuild() {
     let config;
-    let configVike;
+    let vikeConfigGlobal;
     return [
         {
             name: 'vike:autoFullBuild',
             apply: 'build',
             enforce: 'pre',
             async configResolved(config_) {
-                configVike = await getConfigVike(config_);
+                const vikeConfig = await getVikeConfig(config_);
+                vikeConfigGlobal = vikeConfig.vikeConfigGlobal;
                 config = config_;
-                abortViteBuildSsr(configVike);
+                abortViteBuildSsr(vikeConfigGlobal);
             },
             writeBundle: {
                 /* We can't use this because it breaks Vite's logging. TODO: try again with latest Vite version.
@@ -29,7 +30,7 @@ function autoFullBuild() {
                 */
                 async handler(_options, bundle) {
                     try {
-                        await triggerFullBuild(config, configVike, bundle);
+                        await triggerFullBuild(config, vikeConfigGlobal, bundle);
                     }
                     catch (err) {
                         // Avoid Rollup prefixing the error with [vike:autoFullBuild], for example see https://github.com/vikejs/vike/issues/472#issuecomment-1276274203
@@ -55,10 +56,10 @@ function autoFullBuild() {
         }
     ];
 }
-async function triggerFullBuild(config, configVike, bundle) {
+async function triggerFullBuild(config, vikeConfigGlobal, bundle) {
     if (config.build.ssr)
         return; // already triggered
-    if (isDisabled(configVike))
+    if (isDisabled(vikeConfigGlobal))
         return;
     // Workaround for @vitejs/plugin-legacy
     //  - The legacy plugin triggers its own Rollup build for the client-side.
@@ -89,19 +90,21 @@ async function triggerFullBuild(config, configVike, bundle) {
         logErrorHint(err);
         process.exit(1);
     }
-    if (configVike.prerender && !configVike.prerender.disableAutoRun && configVike.disableAutoFullBuild !== 'prerender') {
+    if (vikeConfigGlobal.prerender &&
+        !vikeConfigGlobal.prerender.disableAutoRun &&
+        vikeConfigGlobal.disableAutoFullBuild !== 'prerender') {
         await runPrerenderFromAutoRun(configInline, false);
         forceExit = true;
     }
 }
-function abortViteBuildSsr(configVike) {
-    if (configVike.disableAutoFullBuild !== true && isViteCliCall() && getViteConfigFromCli()?.build.ssr) {
+function abortViteBuildSsr(vikeConfigGlobal) {
+    if (vikeConfigGlobal.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(configVike) {
-    const { disableAutoFullBuild } = configVike;
+function isDisabled(vikeConfigGlobal) {
+    const { disableAutoFullBuild } = vikeConfigGlobal;
     if (disableAutoFullBuild === null || disableAutoFullBuild === 'prerender') {
         return !isViteCliCall();
     }

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

@@ -1,4 +1,4 @@
 export { baseUrls };
 import type { Plugin } from 'vite';
-import type { ConfigVikeUserProvided } from '../../../shared/ConfigVike.js';
-declare function baseUrls(configVike?: ConfigVikeUserProvided): Plugin;
+import type { VikeVitePluginOptions } from './importUserCode/v1-design/getVikeConfig/resolveVikeConfigGlobal.js';
+declare function baseUrls(vikeVitePluginOptions?: VikeVitePluginOptions): Plugin;