vike 0.4.212 → 0.4.214

package/dist/cjs/node/plugin/plugins/vite6HmrRegressionWorkaround.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.vite6HmrRegressionWorkaround = vite6HmrRegressionWorkaround;
+// https://vite.dev/guide/migration (will be 404 after vite@7 release) > search for `hmrReload()`
+// https://v6.vite.dev/guide/migration (will exist after vite@7 release) > search for `hmrReload()`
+// Workaround seems to work for docs page /banner (which is HTML-only)
+// But doesn't seem to work for /examples/render-modes/ (see https://github.com/vikejs/vike/pull/2069 commit `renable HMR test for HTML-only`)
+function vite6HmrRegressionWorkaround() {
+    return {
+        name: 'vike:vite6HmrRegressionWorkaround',
+        enforce: 'post',
+        hotUpdate: {
+            order: 'post',
+            handler({ modules, server, timestamp }) {
+                if (this.environment.name !== 'ssr')
+                    return;
+                let hasSsrOnlyModules = false;
+                const invalidatedModules = new Set();
+                for (const mod of modules) {
+                    if (mod.id == null)
+                        continue;
+                    const clientModule = server.environments.client.moduleGraph.getModuleById(mod.id);
+                    if (clientModule != null)
+                        continue;
+                    this.environment.moduleGraph.invalidateModule(mod, invalidatedModules, timestamp, true);
+                    hasSsrOnlyModules = true;
+                }
+                if (hasSsrOnlyModules) {
+                    server.ws.send({ type: 'full-reload' });
+                    return [];
+                }
+            }
+        }
+    };
+}

package/dist/cjs/node/plugin/shared/getEnvVarObject.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEnvVarObject = getEnvVarObject;
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+const utils_js_1 = require("../utils.js");
+const json5_1 = __importDefault(require("json5"));
+function getEnvVarObject(envVarName
+/* Let's eventually implement this for Vike's config as well
+| 'VIKE_CONFIG'
+*/
+) {
+    const valueStr = process.env[envVarName];
+    if (!valueStr)
+        return null;
+    let value;
+    try {
+        value = json5_1.default.parse(valueStr);
+    }
+    catch (err) {
+        console.error(err);
+        (0, utils_js_1.assertUsage)(false, `Cannot parse ${envVarName} (see error above) because it's set to the following which isn't a valid JSON5 string: ${picocolors_1.default.bold(valueStr)}`);
+    }
+    (0, utils_js_1.assertUsage)(value, `${envVarName} should define an object but it's ${picocolors_1.default.bold(String(value))} instead.`);
+    (0, utils_js_1.assertUsage)((0, utils_js_1.isObject)(value), `${envVarName} should define an object but it's set to the following which isn't an object: ${picocolors_1.default.bold(valueStr)}`);
+    return value;
+}

package/dist/cjs/node/plugin/utils.js

@@ -1,5 +1,5 @@
 "use strict";
-// Utils needed by Vike's Vite plugin.
+// Utils needed by Vike's Vite plugin
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -15,7 +15,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-// We assume all runtime entries will load this utils.ts file
+// We call onLoad() here so that it's called even when only a subset of the plugin is loaded. (Making the assert() calls inside onLoad() a lot stronger.)
 const onLoad_js_1 = require("./onLoad.js");
 (0, onLoad_js_1.onLoad)();
 // We tolerate the fact that we load all of the runtime utils even though some of it isn't needed

package/dist/cjs/node/prerender/index.js

@@ -1,5 +1,12 @@
 "use strict";
+// TODO/v1-release: remove this file
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.prerender = void 0;
-var runPrerender_js_1 = require("./runPrerender.js");
-Object.defineProperty(exports, "prerender", { enumerable: true, get: function () { return runPrerender_js_1.runPrerenderFromAPI; } });
+var prerender_js_1 = require("../api/prerender.js");
+Object.defineProperty(exports, "prerender", { enumerable: true, get: function () { return prerender_js_1.prerender; } });
+const assert_js_1 = require("../../utils/assert.js");
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+(0, assert_js_1.assertWarning)(false, `${picocolors_1.default.cyan("import { prerender } from 'vike/prerender'")} is deprecated in favor of ${picocolors_1.default.cyan("import { prerender } from 'vike/api'")}`, { onlyOnce: true });

package/dist/cjs/node/prerender/runPrerender.js

@@ -27,8 +27,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runPrerenderFromAPI = runPrerenderFromAPI;
-exports.runPrerenderFromCLI = runPrerenderFromCLI;
-exports.runPrerenderFromAutoFullBuild = runPrerenderFromAutoFullBuild;
+exports.runPrerenderFromCLIPrerenderCommand = runPrerenderFromCLIPrerenderCommand;
+exports.runPrerenderFromAutoRun = runPrerenderFromAutoRun;
 exports.runPrerender_forceExit = runPrerender_forceExit;
 require("../runtime/page-files/setup.js");
 const path_1 = __importDefault(require("path"));
@@ -56,32 +56,38 @@ const getVikeConfig_js_1 = require("../plugin/plugins/importUserCode/v1-design/g
 const logErrorHint_js_1 = require("../runtime/renderPage/logErrorHint.js");
 const executeHook_js_1 = require("../../shared/hooks/executeHook.js");
 const getConfigValueBuildTime_js_1 = require("../../shared/page-configs/getConfigValueBuildTime.js");
+const enhanceViteConfig_js_1 = require("../api/enhanceViteConfig.js");
 async function runPrerenderFromAPI(options = {}) {
     await runPrerender(options, 'prerender()');
     // - We purposely propagate the error to the user land, so that the error interrupts the user land. It's also, I guess, a nice-to-have that the user has control over the error.
     // - We don't use logErrorHint() because we don't have control over what happens with the error. For example, if the user land purposely swallows the error then the hint shouldn't be logged. Also, it's best if the hint is shown to the user *after* the error, but we cannot do/guarentee that.
 }
-async function runPrerenderFromCLI(options) {
+async function runPrerenderFromCLIPrerenderCommand() {
     try {
-        await runPrerender(options, '$ vike prerender');
+        const { viteConfigEnhanced } = await (0, enhanceViteConfig_js_1.enhanceViteConfig)(undefined, 'prerender');
+        await runPrerender({ viteConfig: viteConfigEnhanced }, '$ vike prerender');
     }
     catch (err) {
         console.error(err);
+        // Error may come from user-land; we need to use logErrorHint()
         (0, logErrorHint_js_1.logErrorHint)(err);
         process.exit(1);
     }
+    runPrerender_forceExit();
 }
-async function runPrerenderFromAutoFullBuild(options) {
+async function runPrerenderFromAutoRun(viteConfig, forceExit) {
     try {
-        await runPrerender(options, null);
+        await runPrerender({ viteConfig });
     }
     catch (err) {
         console.error(err);
         (0, logErrorHint_js_1.logErrorHint)(err);
         process.exit(1);
     }
+    if (forceExit)
+        runPrerender_forceExit();
 }
-async function runPrerender(options, manuallyTriggered) {
+async function runPrerender(options = {}, standaloneTrigger) {
     checkOutdatedOptions(options);
     (0, globalContext_js_1.setGlobalContext_isPrerendering)();
     (0, getHook_js_1.getHook_setIsPrerenderering)();
@@ -98,8 +104,8 @@ async function runPrerender(options, manuallyTriggered) {
     const { root } = viteConfig;
     const prerenderConfig = configVike.prerender;
     if (!prerenderConfig) {
-        (0, utils_js_1.assert)(manuallyTriggered);
-        (0, utils_js_1.assertWarning)(prerenderConfig, `You're executing ${picocolors_1.default.cyan(manuallyTriggered)} but the config ${picocolors_1.default.cyan('prerender')} isn't set to true`, {
+        (0, utils_js_1.assert)(standaloneTrigger);
+        (0, utils_js_1.assertWarning)(prerenderConfig, `You're executing ${picocolors_1.default.cyan(standaloneTrigger)} but the config ${picocolors_1.default.cyan('prerender')} isn't set to true`, {
             onlyOnce: true
         });
     }

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

@@ -219,7 +219,7 @@ function assertBuildEntries(buildEntries, isPreRendering) {
     const errMsg = [
         `You are tyring to run`,
         isPreRendering ? 'pre-rendering' : 'the server for production',
-        `but your app isn't built yet. Run ${picocolors_1.default.cyan('$ vite build')} before `,
+        `but your app isn't built yet. Run ${picocolors_1.default.cyan('$ vike build')} before `,
         isPreRendering ? 'pre-rendering.' : 'running the server.'
     ].join(' ');
     (0, utils_js_1.assertUsage)(buildEntries, errMsg);

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

@@ -1,4 +1,5 @@
 "use strict";
+// Utils needed by Vike's server runtime
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -15,7 +16,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 require("../../utils/trackLogs.js");
-// We assume all runtime entries will load this utils.ts file
+// We call onLoad() here so that it's called even when only a subset of the runtime is loaded. (Making the assert() calls inside onLoad() a lot stronger.)
 const onLoad_js_1 = require("./onLoad.js");
 (0, onLoad_js_1.onLoad)();
 __exportStar(require("../../utils/assert.js"), exports);

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.212';
+exports.PROJECT_VERSION = '0.4.214';

package/dist/cjs/utils/assertNodeEnv.js

@@ -37,7 +37,7 @@ function assertNodeEnv_runtime(isViteDev) {
         return;
     const nodeEnvDesc = getNodeEnvDesc();
     // TODO: make it assertUsage() again once #1528 is implemented.
-    const errMsg = `Running ${isViteDev ? picocolors_1.default.cyan('$ vite dev') : 'app in production'} while the ${nodeEnvDesc} which is contradictory, see https://vike.dev/NODE_ENV`;
+    const errMsg = `Running ${isViteDev ? picocolors_1.default.cyan('$ vike dev') : 'app in production'} while the ${nodeEnvDesc} which is contradictory, see https://vike.dev/NODE_ENV`;
     (0, assert_js_1.assertWarning)(false, errMsg, { onlyOnce: true });
 }
 function assertNodeEnv_onVikePluginLoad() {

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

@@ -1,5 +1,5 @@
-// Utils needed by Client Routing.
-// We assume all runtime entries will load this utils.ts file
+// Utils needed by Vike's client runtime (with Client Routing)
+// We call onLoad() here so that it's called even when only a subset of the runtime is loaded. (Making the assert() calls inside onLoad() a lot stronger.)
 import { onLoad } from './onLoad.js';
 onLoad();
 export * from '../../utils/assert.js';

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

@@ -1,5 +1,5 @@
-// Utils needed by Server Routing.
-// We assume all runtime entries will load this utils.ts file
+// Utils needed by Vike's client runtime (with Server Routing)
+// We call onLoad() here so that it's called even when only a subset of the runtime is loaded. (Making the assert() calls inside onLoad() a lot stronger.)
 import { onLoad } from './onLoad.js';
 onLoad();
 export * from '../../utils/assert.js';

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

@@ -0,0 +1,10 @@
+export { APIOptions };
+import type { InlineConfig } from 'vite';
+type APIOptions = {
+    /**
+     * Vite config.
+     *
+     * https://vike.dev/api
+     */
+    viteConfig?: InlineConfig;
+};

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

@@ -0,0 +1,6 @@
+export { build };
+import type { APIOptions } from './APIOptions.js';
+declare function build(options?: APIOptions): Promise<{
+    outputClient: import("rollup").RollupOutput | import("rollup").RollupOutput[] | import("rollup").RollupWatcher;
+    outputServer: import("rollup").RollupOutput | import("rollup").RollupOutput[] | import("rollup").RollupWatcher;
+}>;

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

@@ -0,0 +1,25 @@
+export { build };
+import { enhanceViteConfig } from './enhanceViteConfig.js';
+import { build as buildVite } from 'vite';
+async function build(options = {}) {
+    const { viteConfigEnhanced, configVike } = await enhanceViteConfig(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') {
+        const { runPrerenderFromAutoRun } = await import('../prerender/runPrerender.js');
+        await runPrerenderFromAutoRun(viteConfigEnhanced, true);
+    }
+    return { outputClient, outputServer };
+}
+function setSSR(viteConfig) {
+    return {
+        ...viteConfig,
+        build: {
+            ...viteConfig.build,
+            ssr: true
+        }
+    };
+}

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

@@ -0,0 +1,3 @@
+export { dev };
+import type { APIOptions } from './APIOptions.js';
+declare function dev(options?: APIOptions): Promise<import("vite").ViteDevServer>;

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

@@ -0,0 +1,8 @@
+export { dev };
+import { enhanceViteConfig } from './enhanceViteConfig.js';
+import { createServer } from 'vite';
+async function dev(options = {}) {
+    const { viteConfigEnhanced } = await enhanceViteConfig(options.viteConfig, 'dev');
+    const server = await createServer(viteConfigEnhanced);
+    return server;
+}

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

@@ -0,0 +1,6 @@
+export { enhanceViteConfig };
+import type { InlineConfig } from 'vite';
+declare function enhanceViteConfig(viteConfig: InlineConfig | undefined, command: 'build' | 'dev' | 'preview' | 'prerender'): Promise<{
+    viteConfigEnhanced: InlineConfig;
+    configVike: import("../../shared/ConfigVike.js").ConfigVikeResolved;
+}>;

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

@@ -0,0 +1,27 @@
+export { enhanceViteConfig };
+import { resolveConfig } from 'vite';
+import { getConfigVike } from '../shared/getConfigVike.js';
+import { pluginName } from '../plugin/plugins/commonConfig/pluginName.js';
+async function enhanceViteConfig(viteConfig = {}, command) {
+    let viteConfigResolved = await resolveViteConfig(viteConfig, command);
+    let viteConfigEnhanced = viteConfig;
+    // Add vike to plugins if not present
+    if (!viteConfigResolved.plugins.some((p) => p.name === pluginName)) {
+        // Using a dynamic import because the script calling the Vike API may not live in the same place as vite.config.js, thus have vike/plugin may resolved to two different node_modules/vike directories
+        const { plugin: vikePlugin } = await import('../plugin/index.js');
+        viteConfigEnhanced = {
+            ...viteConfig,
+            plugins: [...(viteConfig.plugins ?? []), vikePlugin()]
+        };
+        viteConfigResolved = await resolveViteConfig(viteConfigEnhanced, command);
+    }
+    const configVike = await getConfigVike(viteConfigResolved);
+    // TODO: enable Vike extensions to add Vite plugins
+    return {
+        viteConfigEnhanced,
+        configVike
+    };
+}
+async function resolveViteConfig(viteConfig, command) {
+    return await resolveConfig(viteConfig, command === 'build' || command === 'prerender' ? 'build' : 'serve', 'custom', command === 'dev' ? 'development' : 'production', command === 'preview');
+}

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

@@ -0,0 +1,12 @@
+export { build_ as build };
+export { dev_ as dev };
+export { preview_ as preview };
+export { prerender_ as prerender };
+import type { build } from './build.js';
+import type { dev } from './dev.js';
+import type { preview } from './preview.js';
+import type { prerender } from './prerender.js';
+declare const build_: typeof build;
+declare const dev_: typeof dev;
+declare const preview_: typeof preview;
+declare const prerender_: typeof prerender;

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

@@ -0,0 +1,10 @@
+export { build_ as build };
+export { dev_ as dev };
+export { preview_ as preview };
+export { prerender_ as prerender };
+import { assertIsNotBrowser } from '../../utils/assertIsNotBrowser.js';
+assertIsNotBrowser();
+const build_ = async (...args) => (await import('./build.js')).build(...args);
+const dev_ = async (...args) => (await import('./dev.js')).dev(...args);
+const preview_ = async (...args) => (await import('./preview.js')).preview(...args);
+const prerender_ = async (...args) => (await import('./prerender.js')).prerender(...args);

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

@@ -0,0 +1,3 @@
+export { prerender };
+import { type PrerenderOptions } from '../prerender/runPrerender.js';
+declare function prerender(options?: PrerenderOptions): Promise<void>;

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

@@ -0,0 +1,8 @@
+export { prerender };
+import { runPrerenderFromAPI } from '../prerender/runPrerender.js';
+import { enhanceViteConfig } from './enhanceViteConfig.js';
+async function prerender(options = {}) {
+    const { viteConfigEnhanced } = await enhanceViteConfig(options.viteConfig, 'prerender');
+    options.viteConfig = viteConfigEnhanced;
+    await runPrerenderFromAPI(options);
+}

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

@@ -0,0 +1,3 @@
+export { preview };
+import type { APIOptions } from './APIOptions.js';
+declare function preview(options?: APIOptions): Promise<import("vite").PreviewServer>;

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

@@ -0,0 +1,8 @@
+export { preview };
+import { enhanceViteConfig } from './enhanceViteConfig.js';
+import { preview as previewVite } from 'vite';
+async function preview(options = {}) {
+    const { viteConfigEnhanced } = await enhanceViteConfig(options.viteConfig, 'preview');
+    const server = await previewVite(viteConfigEnhanced);
+    return server;
+}

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,72 @@
+import { projectInfo } from './utils.js';
+import { dev, build, preview } from '../api/index.js';
+import pc from '@brillout/picocolors';
+import { parseCli } from './parseCli.js';
+cli();
+async function cli() {
+    const { command } = parseCli();
+    if (command === 'dev') {
+        await cmdDev();
+    }
+    else if (command === 'build') {
+        await cmdBuild();
+    }
+    else if (command === 'preview') {
+        await cmdPreview();
+    }
+    else if (command === 'prerender') {
+        await cmdPrerender();
+    }
+}
+async function cmdDev() {
+    const startTime = performance.now();
+    try {
+        const server = await dev();
+        await server.listen();
+        const info = server.config.logger.info;
+        const startupDurationString = pc.dim(`ready in ${pc.reset(pc.bold(String(Math.ceil(performance.now() - startTime))))} ms`);
+        const hasExistingLogs = process.stdout.bytesWritten > 0 || process.stderr.bytesWritten > 0;
+        info(`  ${pc.yellow(`${pc.bold(projectInfo.projectName)} v${projectInfo.projectVersion}`)}  ${startupDurationString}\n`, {
+            clear: !hasExistingLogs
+        });
+        server.printUrls();
+        server.bindCLIShortcuts({ print: true });
+    }
+    catch (err) {
+        console.error(pc.red(`Error while starting dev server:`));
+        // Error comes from Vite; no need to use logErrorHint()
+        console.error(err);
+        process.exit(1);
+    }
+}
+async function cmdBuild() {
+    try {
+        await build();
+    }
+    catch (err) {
+        console.error(pc.red(`Error during build:`));
+        // Error comes from Vite; no need to use logErrorHint()
+        console.error(err);
+        process.exit(1);
+    }
+}
+async function cmdPreview() {
+    try {
+        const server = await preview();
+        server.printUrls();
+        server.bindCLIShortcuts({ print: true });
+    }
+    catch (err) {
+        console.error(pc.red(`Error while starting preview server:`));
+        // Error comes from Vite; no need to use logErrorHint()
+        console.error(err);
+        process.exit(1);
+    }
+}
+async function cmdPrerender() {
+    const { runPrerenderFromCLIPrerenderCommand } = await import('../prerender/runPrerender.js');
+    await runPrerenderFromCLIPrerenderCommand();
+}
+process.on('unhandledRejection', (rejectValue) => {
+    throw rejectValue;
+});

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

@@ -1,2 +1 @@
-import { prerender as prerenderOriginal } from '../prerender/index.js';
-export declare const prerender: typeof prerenderOriginal;
+export { prerender } from '../api/prerender.js';

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

@@ -1,7 +1,5 @@
 // TODO/v1-release: remove this file
-import { prerender as prerenderOriginal } from '../prerender/index.js';
-import { assertWarning } from './utils.js';
-export const prerender = (options) => {
-    assertWarning(false, "`import { prerender } from 'vike/cli'` is deprecated in favor of `import { prerender } from 'vike/prerender'``", { onlyOnce: true, showStackTrace: true });
-    return prerenderOriginal(options);
-};
+export { prerender } from '../api/prerender.js';
+import { assertWarning } from '../../utils/assert.js';
+import pc from '@brillout/picocolors';
+assertWarning(false, `${pc.cyan("import { prerender } from 'vike/cli'")} is deprecated in favor of ${pc.cyan("import { prerender } from 'vike/api'")}`, { onlyOnce: true });

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

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

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

@@ -0,0 +1,56 @@
+export { parseCli };
+import pc from '@brillout/picocolors';
+import { projectInfo, includes } from './utils.js';
+const commands = [
+    { name: 'dev', desc: 'Start development server' },
+    { name: 'build', desc: 'Build for production' },
+    { name: 'preview', desc: 'Start preview server using production build (only works for SSG apps)' },
+    { name: 'prerender', desc: 'Pre-render pages (only needed when partial.disableAutoRun is true)' }
+];
+function parseCli() {
+    const command = (() => {
+        const firstArg = process.argv[2];
+        if (!firstArg) {
+            showHelp();
+        }
+        showHelpOrVersion(firstArg);
+        if (includes(commands.map((c) => c.name), firstArg))
+            return firstArg;
+        wrongUsage(`Unknown command ${pc.bold(firstArg)}`);
+    })();
+    for (const arg of process.argv.slice(3)) {
+        showHelpOrVersion(arg);
+        wrongUsage(`Unknown option ${pc.bold(arg)}`);
+    }
+    return { command };
+}
+function showHelp() {
+    const TAB = ' '.repeat(3);
+    const nameMaxLength = Math.max(...commands.map((c) => c.name.length));
+    console.log([
+        `vike@${projectInfo.projectVersion}`,
+        '',
+        'Usage:',
+        ...[...commands, { name: '-v', desc: "Print Vike's installed version" }].map((c) => `  ${pc.dim('$')} ${pc.bold(`vike ${c.name}`)}${' '.repeat(nameMaxLength - c.name.length)}${TAB}${pc.dim(`# ${c.desc}`)}`),
+        '',
+        `More infos at ${pc.underline('https://vike.dev/cli')}`
+    ].join('\n'));
+    process.exit(1);
+}
+function showHelpOrVersion(arg) {
+    if (arg === '--version' || arg === '-v' || arg === '--v') {
+        showVersion();
+    }
+    if (arg === '--help' || arg === '-h' || arg === '--h') {
+        showHelp();
+    }
+}
+function showVersion() {
+    console.log(projectInfo.projectVersion);
+    process.exit(1);
+}
+function wrongUsage(msg) {
+    console.error(pc.red(msg));
+    console.log();
+    showHelp();
+}

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

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

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

@@ -1,5 +1,7 @@
-// We assume all runtime entries will load this utils.ts file
+// Utils needed by Vike's CLI
+// We call onLoad() here so that it's called even when only a subset of the CLI is loaded. (Making the assert() calls inside onLoad() a lot stronger.)
 import { onLoad } from './onLoad.js';
 onLoad();
 export * from '../../utils/assert.js';
 export * from '../../utils/projectInfo.js';
+export * from '../../utils/includes.js';

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

@@ -27,6 +27,7 @@ import { fileEnv } from './plugins/fileEnv.js';
 import { setResolveClientEntriesDev } from '../runtime/renderPage/getPageAssets.js';
 import { resolveClientEntriesDev } from './resolveClientEntriesDev.js';
 import { workaroundCssModuleHmr } from './plugins/workaroundCssModuleHmr.js';
+import { vite6HmrRegressionWorkaround } from './plugins/vite6HmrRegressionWorkaround.js';
 assertNodeEnv_onVikePluginLoad();
 markEnvAsVikePluginLoaded();
 assertViteVersion();
@@ -52,7 +53,8 @@ function plugin(vikeConfig) {
         baseUrls(vikeConfig),
         envVarsPlugin(),
         fileEnv(),
-        workaroundCssModuleHmr()
+        workaroundCssModuleHmr(),
+        vite6HmrRegressionWorkaround()
     ];
     return plugins;
 }

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

@@ -1,13 +1,17 @@
+// TODO/v1-release: remove this file
 export { autoFullBuild };
 import { build } from 'vite';
 import { assertWarning } from '../utils.js';
-import { runPrerenderFromAutoFullBuild, runPrerender_forceExit } from '../../prerender/runPrerender.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';
 let forceExit = false;
+assertWarning(!isViteCliCall(), `Vite's CLI is deprecated ${pc.underline('https://vike.dev/migration/cli')}`, {
+    onlyOnce: true
+});
 function autoFullBuild() {
     let config;
     let configVike;
@@ -89,7 +93,7 @@ async function triggerFullBuild(config, configVike, bundle) {
         process.exit(1);
     }
     if (configVike.prerender && !configVike.prerender.disableAutoRun && configVike.disableAutoFullBuild !== 'prerender') {
-        await runPrerenderFromAutoFullBuild({ viteConfig: configInline });
+        await runPrerenderFromAutoRun(configInline, false);
         forceExit = true;
     }
 }
@@ -102,10 +106,6 @@ function abortViteBuildSsr(configVike) {
 function isDisabled(configVike) {
     const { disableAutoFullBuild } = configVike;
     if (disableAutoFullBuild === null || disableAutoFullBuild === 'prerender') {
-        // TODO/v1-release: remove autoFullBuild for both Vite's build() API and Vite's CLI
-        //  - Tell users to use `$ vike build` instead of `$ vite build`
-        //  - Remove the whole writeBundle() hook logic
-        //  - make `$ vite build` only build the client-side
         return !isViteCliCall();
     }
     else {