vike 0.4.247-commit-14351e3 → 0.4.247-commit-c3d567b

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

@@ -6,7 +6,10 @@ import type { ApiOptions } from './types.js';
  *
  * https://vike.dev/api#dev
  */
-declare function dev(options?: ApiOptions): Promise<{
+declare function dev(options?: ApiOptions & {
+    startupLog?: boolean;
+}): Promise<{
     viteServer: ViteDevServer;
     viteConfig: ResolvedConfig;
+    viteVersion: string;
 }>;

package/dist/node/api/dev.js

@@ -1,16 +1,68 @@
 export { dev };
 import { prepareViteApiCall } from './prepareViteApiCall.js';
-import { createServer } from 'vite';
+import { createServer, version as viteVersionVike } from 'vite';
+import { viteVersionUser } from '../vite/plugins/pluginCommon.js';
+import { colorVike, colorVite, PROJECT_VERSION } from './utils.js';
+import pc from '@brillout/picocolors';
+import { processStartupLog } from '../vite/shared/loggerVite.js';
 /**
  * Programmatically trigger `$ vike dev`
  *
  * https://vike.dev/api#dev
  */
 async function dev(options = {}) {
+    const startTime = performance.now();
     const { viteConfigFromUserResolved } = await prepareViteApiCall(options, 'dev');
     const server = await createServer(viteConfigFromUserResolved);
+    const viteVersion = viteVersionUser ?? viteVersionVike;
+    const viteServer = server;
+    const viteConfig = server.config;
+    if (viteServer.httpServer)
+        await viteServer.listen();
+    if (options.startupLog)
+        printStartupLog(viteServer, viteConfig, viteVersion, startTime);
     return {
-        viteServer: server,
-        viteConfig: server.config,
+        viteServer,
+        viteConfig,
+        viteVersion,
     };
 }
+async function printStartupLog(viteServer, viteConfig, viteVersion, startTime) {
+    const startupDurationString = pc.dim(`ready in ${pc.reset(pc.bold(String(Math.ceil(performance.now() - startTime))))} ms`);
+    const sep = pc.dim('·');
+    const firstLine = `\n  ${colorVike('Vike')} ${pc.yellow(`v${PROJECT_VERSION}`)} ${sep} ${colorVite('Vite')} ${pc.cyan(`v${viteVersion}`)} ${sep} ${startupDurationString}\n`;
+    const ret = processStartupLog(firstLine, viteConfig);
+    console.log(ret.firstLine);
+    const { isCompact } = ret;
+    // We don't call viteServer.printUrls() because Vite throws an error if `resolvedUrls` is missing:
+    // https://github.com/vitejs/vite/blob/df5a30d2690a2ebc4824a79becdcef30538dc602/packages/vite/src/node/server/index.ts#L745
+    printServerUrls(viteServer.resolvedUrls || { local: ['http://localhost:3000'], network: [] }, viteConfig.server.host);
+    viteServer.bindCLIShortcuts({ print: true });
+    if (!isCompact)
+        console.log();
+}
+// Copied & adapted from Vite
+// https://github.com/vitejs/vite/blob/df5a30d2690a2ebc4824a79becdcef30538dc602/packages/vite/src/node/logger.ts#L168-L188
+function printServerUrls(urls, optionsHost) {
+    // [Begin] interop
+    const colors = pc;
+    const info = (msg) => console.log(msg);
+    // [End] interop
+    const colorUrl = (url) => colors.underline(removeTrailingSlash(url));
+    for (const url of urls.local) {
+        info(`  ${colors.green('➜')}  ${colors.bold('Local')}:   ${colorUrl(url)}`);
+    }
+    for (const url of urls.network) {
+        info(`  ${colors.green('➜')}  ${colors.bold('Network')}: ${colorUrl(url)}`);
+    }
+    if (urls.network.length === 0 && optionsHost === undefined) {
+        info(colors.dim(`  ${colors.green('➜')}  ${colors.bold('Network')}: use `) +
+            colors.bold('--host') +
+            colors.dim(' to expose'));
+    }
+}
+function removeTrailingSlash(url) {
+    if (url.endsWith('/'))
+        return url.slice(0, -1); // remove trailing slash
+    return url;
+}

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

@@ -6,3 +6,6 @@ export * from '../../utils/assertVersion.js';
 export * from '../../utils/pick.js';
 export * from '../../utils/assertSetup.js';
 export * from '../../utils/isCallable.js';
+export * from '../../utils/colors.js';
+export * from '../../utils/colorVike.js';
+export * from '../../utils/PROJECT_VERSION.js';

package/dist/node/api/utils.js

@@ -10,3 +10,6 @@ export * from '../../utils/assertVersion.js';
 export * from '../../utils/pick.js';
 export * from '../../utils/assertSetup.js';
 export * from '../../utils/isCallable.js';
+export * from '../../utils/colors.js';
+export * from '../../utils/colorVike.js';
+export * from '../../utils/PROJECT_VERSION.js';

package/dist/node/cli/entry.js

@@ -1,4 +1,3 @@
-import { PROJECT_VERSION } from './utils.js';
 import { dev, build, preview } from '../api/index.js';
 import pc from '@brillout/picocolors';
 import { parseCli } from './parseCli.js';
@@ -21,23 +20,8 @@ async function cli() {
     }
 }
 async function cmdDev() {
-    const startTime = performance.now();
     try {
-        const { viteServer } = await dev();
-        if (viteServer.httpServer) {
-            await viteServer.listen();
-            const info = viteServer.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('Vike')} v${PROJECT_VERSION}`)}  ${startupDurationString}\n`, {
-                clear: !hasExistingLogs,
-            });
-            viteServer.printUrls();
-        }
-        else {
-            // vike-server => middleware mode => `viteServer.httpServer === null`
-        }
-        viteServer.bindCLIShortcuts({ print: true });
+        await dev({ startupLog: true });
     }
     catch (err) {
         console.error(pc.red(`Error while starting dev server:`));

package/dist/node/vite/plugins/build/pluginModuleBanner.js

@@ -24,9 +24,9 @@ function pluginModuleBanner() {
             },
             transform: {
                 order: 'post',
-                /* Using a Rolldown hook filter doesn't make sense here — we use applyToEnvironment() to conditionally apply this plugin.
-              filter: {},
-              */
+                /* Using a Rolldown hook filter doesn't make sense here: we apply this transformer to each module. But we use applyToEnvironment() to conditionally apply this plugin.
+                filter: {},
+                */
                 handler(code, id) {
                     const { minify } = this.environment.config.build;
                     assert(minify === false, { minify });

package/dist/node/vite/plugins/pluginCommon.d.ts

@@ -1,4 +1,5 @@
 export { pluginCommon };
+export declare let viteVersionUser: string | null | undefined;
 import { type InlineConfig, type Plugin } from 'vite';
 import type { VitePluginServerEntryOptions } from '@brillout/vite-plugin-server-entry/plugin';
 declare module 'vite' {

package/dist/node/vite/plugins/pluginCommon.js

@@ -1,4 +1,5 @@
 export { pluginCommon };
+export let viteVersionUser = null;
 import { assert, assertUsage, assertWarning, hasProp, isDevCheck, isDocker, isExactlyOneTruthy, isObject, isVitest, } from '../utils.js';
 import { assertRollupInput } from './build/pluginBuildConfig.js';
 import { installRequireShim_setUserRootDir } from '@brillout/require-shim';
@@ -19,6 +20,7 @@ function pluginCommon(vikeVitePluginOptions) {
             config: {
                 order: 'pre',
                 async handler(configFromUser, env) {
+                    viteVersionUser = this?.meta?.viteVersion; // is `undefined` on old Vite versions
                     const isDev = isDevCheck(env);
                     const isBuild = env.command === 'build';
                     const isPreview = env.isPreview;

package/dist/node/vite/plugins/pluginDev.js

@@ -4,11 +4,9 @@ import { determineOptimizeDeps } from './pluginDev/determineOptimizeDeps.js';
 import { determineFsAllowList } from './pluginDev/determineFsAllowList.js';
 import { addSsrMiddleware } from '../shared/addSsrMiddleware.js';
 import { applyDev, assertWarning, isDocker, isDebugError } from '../utils.js';
-import { improveViteLogs } from '../shared/loggerVite.js';
+import { interceptViteLogs } from '../shared/loggerVite.js';
 import pc from '@brillout/picocolors';
-if (isDebugError()) {
-    Error.stackTraceLimit = Infinity;
-}
+import { swallowViteLogConnected, swallowViteLogConnected_clean } from '../shared/loggerVite.js';
 function pluginDev() {
     let config;
     return [
@@ -44,21 +42,20 @@ function pluginDev() {
                     config = config_;
                     await determineOptimizeDeps(config);
                     await determineFsAllowList(config);
-                    if (!isDebugError()) {
-                        improveViteLogs(config);
-                    }
+                    interceptViteLogs(config);
                     logDockerHint(config.server.host);
                 },
             },
         },
         {
-            name: 'vike:pluginDev:addSsrMiddleware',
+            name: 'vike:pluginDev:post',
             apply: applyDev,
             // The SSR middleware should be last middleware
             enforce: 'post',
             configureServer: {
                 order: 'post',
                 handler(server) {
+                    swallowViteLogConnected_clean(); // If inside a configureServer() `pre` hook => too early
                     const hasHonoViteDevServer = !!config.plugins.find((p) => p.name === '@hono/vite-dev-server');
                     if (config.server.middlewareMode || hasHonoViteDevServer)
                         return;
@@ -76,6 +73,12 @@ function pluginDev() {
                     }
                 },
             },
+            configResolved: {
+                order: 'post',
+                handler() {
+                    swallowViteLogConnected();
+                },
+            },
         },
     ];
 }

package/dist/node/vite/shared/loggerDev/errorWithCodeSnippet.d.ts

@@ -10,6 +10,7 @@ type ErrorWithCodeSnippet = {
     plugin?: string;
 };
 declare function isErrorWithCodeSnippet(err: unknown): err is ErrorWithCodeSnippet;
-declare function getPrettyErrorWithCodeSnippet(err: ErrorWithCodeSnippet, userRootDir: string): string;
+declare function getPrettyErrorWithCodeSnippet(err: ErrorWithCodeSnippet, userRootDir: string): `Failed to transpile ${string} because:
+${string}`;
 declare function getPrettyErrMessage(err: ErrorWithCodeSnippet): string | null;
 declare function isEquivalentErrorWithCodeSnippet(err1: unknown, err2: unknown): boolean;

package/dist/node/vite/shared/loggerDev/errorWithCodeSnippet.js

@@ -45,11 +45,7 @@ function getPrettyErrorWithCodeSnippet(err, userRootDir) {
     //*/
     assert(isErrorWithCodeSnippet(err));
     let { id, frame } = err;
-    const msgFirstLine = [
-        pc.red('Failed to transpile'),
-        pc.bold(pc.red(getFilePathToShowToUserUnknown(id, userRootDir))),
-        pc.red('because:'),
-    ].join(' ');
+    const msgFirstLine = `${pc.red('Failed to transpile')} ${pc.bold(pc.red(getFilePathToShowToUserUnknown(id, userRootDir)))} ${pc.red('because:')}`;
     const errMsg = getPrettyErrMessage(err);
     if (errMsg && containsCodeSnippet(errMsg)) {
         // Conditionally swallowing frame is a risky move but worth it thanks to logErrorDebugNote()
@@ -65,15 +61,16 @@ function getPrettyErrorWithCodeSnippet(err, userRootDir) {
         assert(frame);
         frame = pc.yellow(frame);
     }
-    let msg = [msgFirstLine, errMsg, frame].filter(Boolean).join('\n');
-    msg = removeEmptyLines(msg);
+    let errMsgCodeSnippet = [errMsg, frame].filter(Boolean).join('\n');
+    errMsgCodeSnippet = removeEmptyLines(errMsgCodeSnippet);
+    const errMsgFormatted = `${msgFirstLine}\n${errMsgCodeSnippet}`;
     /* Vite already does a fairly good job at showing a concise error in the layover
     server.ws.send({
       type: 'error',
       err: msg
     })
     */
-    return msg;
+    return errMsgFormatted;
 }
 function getPrettyErrMessage(err) {
     const { id, frame } = err;

package/dist/node/vite/shared/loggerDev.js

@@ -12,7 +12,7 @@ export { logErrorServerDev };
 import { isAbortError } from '../../../shared-server-client/route/abort.js';
 import { getViteConfig } from '../../../server/runtime/globalContext.js';
 import { assertPageContext_logRuntime, setLogRuntimeDev, } from '../../../server/runtime/loggerRuntime.js';
-import { addOnBeforeAssertErr, assert, assertIsNotProductionRuntime, formatHintLog, hasGreen, hasProp, hasRed, hasYellow, isDebugError, stripAnsi, } from '../utils.js';
+import { addOnBeforeAssertErr, assert, assertIsNotProductionRuntime, colorVike, colorVite, formatHintLog, hasGreen, hasProp, hasRed, hasYellow, isDebugError, stripAnsi, } from '../utils.js';
 import { isErrorWithCodeSnippet, getPrettyErrorWithCodeSnippet } from './loggerDev/errorWithCodeSnippet.js';
 import { getConfigExecutionErrorIntroMsg, getConfigBuildErrorFormatted, } from './resolveVikeConfigInternal/transpileAndExecuteFile.js';
 import pc from '@brillout/picocolors';
@@ -27,6 +27,8 @@ addOnBeforeAssertErr((err) => {
     // We must directly apply vite.ssrFixStacktrace() to `assertWarning(..., { showStackTrace: true })` because warnings aren't caught by the try-catch of renderPageServer()
     applyViteSourceMapToStackTrace(err);
 });
+// Note shown to user when Vike completely modifies the error message (which is somewhat risky)
+const errorDebugNote = pc.dim(formatHintLog("Error isn't helpful? See https://vike.dev/debug#verbose-errors"));
 function logRuntimeInfoDev(msg, pageContext, logType) {
     assertPageContext_logRuntime(pageContext);
     const tagSource = getTagSource(pageContext?._requestId);
@@ -55,10 +57,9 @@ function logErrorServerDev(err, pageContext, errorComesFromVite = false) {
         // We handle transpile errors globally because wrapping viteDevServer.ssrLoadModule() wouldn't be enough: transpile errors can be thrown not only when calling viteDevServer.ssrLoadModule() but also later when loading user code with import() (since Vite lazy-transpiles import() calls)
         const viteConfig = getViteConfig();
         assert(viteConfig);
-        let message = getPrettyErrorWithCodeSnippet(err, viteConfig.root);
-        assert(stripAnsi(message).startsWith('Failed to transpile'));
-        message = prependTags(message, '[vite]', tagSource, 'error');
-        message = appendErrorDebugNote(message);
+        const errMsgFormatted = getPrettyErrorWithCodeSnippet(err, viteConfig.root);
+        assert(stripAnsi(errMsgFormatted).startsWith('Failed to transpile'));
+        const message = `${getTags(errMsgFormatted, '[vite]', tagSource, 'error')}${errMsgFormatted}\n${errorDebugNote}`;
         const errBetter = getBetterError(err, { message, hideStack: true });
         logErr(errBetter);
         return;
@@ -67,8 +68,7 @@ function logErrorServerDev(err, pageContext, errorComesFromVite = false) {
         const errMsgFormatted = getConfigBuildErrorFormatted(err);
         if (errMsgFormatted) {
             assert(stripAnsi(errMsgFormatted).startsWith('Failed to transpile'));
-            let message = errMsgFormatted;
-            message = prependTags(message, '[vike]', tagSource, 'error');
+            const message = `${getTagsError(errMsgFormatted, tagSource)}${errMsgFormatted}\n${errorDebugNote}`;
             const errBetter = getBetterError(err, { message, hideStack: true });
             logErr(errBetter);
             return;
@@ -78,9 +78,8 @@ function logErrorServerDev(err, pageContext, errorComesFromVite = false) {
         const errIntro = getConfigExecutionErrorIntroMsg(err);
         if (errIntro) {
             assert(stripAnsi(errIntro).startsWith('Failed to execute'));
-            let message = getErrMsgWithIntro(err, errIntro);
-            message = prependTags(message, '[vike]', tagSource, 'error');
-            const errBetter = getBetterError(err, { message });
+            const prepend = `${getTagsError(errIntro, tagSource)}${errIntro}\n`;
+            const errBetter = getBetterError(err, { message: { prepend } });
             logErr(errBetter);
             return;
         }
@@ -90,26 +89,24 @@ function logErrorServerDev(err, pageContext, errorComesFromVite = false) {
         if (hook) {
             const { hookName, hookFilePath } = hook;
             const errIntro = pc.red(`Following error was thrown by the ${hookName}() hook defined at ${hookFilePath}`);
-            let message = getErrMsgWithIntro(err, errIntro);
-            message = prependTags(message, '[vike]', tagSource, 'error');
-            const errBetter = getBetterError(err, { message });
+            const prepend = `${getTagsError(errIntro, tagSource)}${errIntro}\n`;
+            const errBetter = getBetterError(err, { message: { prepend } });
             logErr(errBetter);
             return;
         }
     }
     if (tagSource) {
         const errIntro = pc.bold(pc.red(`[Error] ${errorComesFromVite ? 'Transpilation error' : 'An error was thrown'}:`));
-        let message = getErrMsgWithIntro(err, errIntro);
-        message = prependTags(message, '[vike]', tagSource, 'error');
-        const errBetter = getBetterError(err, { message });
+        const prepend = `${getTagsError(errIntro, tagSource)}${errIntro}\n`;
+        const errBetter = getBetterError(err, { message: { prepend } });
         logErr(errBetter);
         return;
     }
     logErr(err);
 }
-function logDev(msg, logType, tagSource, tagTool, doNotPrependTags) {
-    if (!doNotPrependTags) {
-        msg = prependTags(msg, tagTool, tagSource, logType);
+function logDev(msg, logType, tagSource, tagTool, doNotAddTags) {
+    if (!doNotAddTags) {
+        msg = getTags(msg, tagTool, tagSource, logType) + msg;
     }
     if (logType === 'info') {
         console.log(msg);
@@ -130,11 +127,6 @@ function logDev(msg, logType, tagSource, tagTool, doNotPrependTags) {
     }
     assert(false);
 }
-// Note shown to user when Vike modifies errors in a risky fashion.
-function appendErrorDebugNote(errMsg) {
-    const errorDebugNote = pc.dim(formatHintLog("Error isn't helpful? See https://vike.dev/debug#verbose-errors"));
-    return errMsg + '\n' + errorDebugNote;
-}
 function getTagSource(requestId = null) {
     const requestIdFromStore = getHttpRequestId_withAsyncHook();
     if (requestIdFromStore !== null) {
@@ -148,7 +140,7 @@ function getTagSource(requestId = null) {
     if (requestId === null)
         return null;
     // const tagSource = requestId % 2 === 1 ? (`request-${requestId}` as const) : (`request(${requestId})` as const)
-    const tagSource = `request(${requestId})`;
+    const tagSource = `request-${requestId}`;
     return tagSource;
 }
 function applyViteSourceMapToStackTrace(thing) {
@@ -162,29 +154,26 @@ function applyViteSourceMapToStackTrace(thing) {
     // Apply Vite's source maps
     viteDevServer.ssrFixStacktrace(thing);
 }
-function prependTags(msg, tagTool, tagSource, logType) {
-    const color = (s) => {
+function getTagsError(msg, tagSource) {
+    return getTags(msg, '[vike]', tagSource, 'error');
+}
+function getTags(msg, tagTool, tagSource, logType) {
+    const tagToolColored = (() => {
         if (logType === 'error' && !hasRed(msg))
-            return pc.bold(pc.red(s));
+            return pc.bold(pc.red(tagTool));
         if (logType === 'error-resolve' && !hasGreen(msg))
-            return pc.bold(pc.green(s));
+            return pc.bold(pc.green(tagTool));
         if (logType === 'warn' && !hasYellow(msg))
-            return pc.yellow(s);
+            return pc.yellow(tagTool);
         if (tagTool === '[vite]')
-            return pc.bold(pc.cyan(s));
+            return colorVite(tagTool);
         if (tagTool === '[vike]')
-            return pc.bold(pc.cyan(s));
+            return colorVike(tagTool);
         assert(false);
-    };
-    let tag = color(tagTool);
-    if (tagSource) {
-        tag = tag + pc.dim(`[${tagSource}]`);
-    }
+    })();
     const timestamp = pc.dim(new Date().toLocaleTimeString());
-    const whitespace = /\s|\[/.test(stripAnsi(msg)[0]) ? '' : ' ';
-    return `${timestamp} ${tag}${whitespace}${msg}`;
-}
-function getErrMsgWithIntro(err, errIntro) {
-    const errMsg = String(err?.message || '');
-    return errIntro + '\n' + errMsg;
+    const whitespace = (/\s|\[/.test(stripAnsi(msg)[0]) ? '' : ' ');
+    const tagSourceStr = (!tagSource ? '' : pc.dim(`[${tagSource}]`));
+    const tags = `${timestamp} ${tagToolColored}${tagSourceStr}${whitespace}`;
+    return tags;
 }

package/dist/node/vite/shared/loggerVite.d.ts

@@ -1,3 +1,16 @@
-export { improveViteLogs };
+export { interceptViteLogs };
+export { processStartupLog };
+export { swallowViteLogForceOptimization_enable };
+export { swallowViteLogForceOptimization_disable };
+export { swallowViteLogConnected };
+export { swallowViteLogConnected_clean };
 import type { ResolvedConfig } from 'vite';
-declare function improveViteLogs(config: ResolvedConfig): void;
+declare function interceptViteLogs(config: ResolvedConfig): void;
+declare function processStartupLog(firstLine: string, config: ResolvedConfig): {
+    firstLine: string;
+    isCompact: boolean;
+};
+declare function swallowViteLogForceOptimization_enable(): void;
+declare function swallowViteLogForceOptimization_disable(): void;
+declare function swallowViteLogConnected(): void;
+declare function swallowViteLogConnected_clean(): void;

package/dist/node/vite/shared/loggerVite.js

@@ -1,17 +1,32 @@
-export { improveViteLogs };
-import { assert, isDebugError, removeEmptyLines, trimWithAnsi, trimWithAnsiTrailOnly } from '../utils.js';
+export { interceptViteLogs };
+export { processStartupLog };
+export { swallowViteLogForceOptimization_enable };
+export { swallowViteLogForceOptimization_disable };
+export { swallowViteLogConnected };
+export { swallowViteLogConnected_clean };
+import { assert, getGlobalObject, isDebugError, removeEmptyLines, trimWithAnsi, trimWithAnsiTrailOnly, } from '../utils.js';
 import { getHttpRequestId_withAsyncHook } from '../../../server/runtime/asyncHook.js';
 import { logErrorServerDev, logVite } from './loggerDev.js';
-import { removeSuperfluousViteLog } from './loggerVite/removeSuperfluousViteLog.js';
-function improveViteLogs(config) {
+const globalObject = getGlobalObject('vite/shared/loggerDev.ts', {
+    processStartupLog_isCompact: null,
+    processStartupLog_hasViteLoggedStartup: null,
+    processStartupLog_hasViteLoggedHelpShortcut: null,
+    swallowViteLogForceOptimization_enabled: false,
+    swallowViteLogConnected_originalConsoleLog: null,
+});
+function interceptViteLogs(config) {
+    if (isDebugError())
+        return;
     intercept('info', config);
     intercept('warn', config);
     intercept('error', config);
 }
 function intercept(loggerType, config) {
+    let isBeginning = true;
+    setTimeout(() => (isBeginning = false), 10 * 1000);
     config.logger[loggerType] = (msg, options = {}) => {
         assert(!isDebugError());
-        if (removeSuperfluousViteLog(msg))
+        if (swallowViteLogForceOptimization(msg))
             return;
         if (!!options.timestamp) {
             msg = trimWithAnsi(msg);
@@ -20,7 +35,9 @@ function intercept(loggerType, config) {
             // No timestamp => no "[vite]" tag prepended => we don't trim the beginning of the message
             msg = trimWithAnsiTrailOnly(msg);
         }
-        msg = cleanFirstViteLog(msg);
+        if (isBeginning) {
+            msg = processStartupLog_onViteLog(msg, config);
+        }
         if (options.error) {
             // Vite does a poor job of handling errors.
             //  - It doesn't format error code snippets.
@@ -41,12 +58,92 @@ function intercept(loggerType, config) {
         logVite(msg, loggerType, requestId, prependViteTag);
     };
 }
-function cleanFirstViteLog(msg) {
-    const isFirstVitLog = msg.includes('VITE') && msg.includes('ready');
-    if (isFirstVitLog) {
-        return removeEmptyLines(msg);
+// - Clears screen if zero previous log
+// - Manages new lines
+function processStartupLog(firstLine, config) {
+    const shouldClear = processStartupLog_shouldClear(config);
+    if (shouldClear) {
+        config.logger.clearScreen('info');
     }
     else {
-        return msg;
+        // Remove leading new line (for both Vite and Vike's startup log)
+        firstLine = removeEmptyLines(firstLine);
+    }
+    return { firstLine, isCompact: !shouldClear };
+}
+function processStartupLog_shouldClear(config) {
+    const hasLoggedBefore = process.stdout.bytesWritten !== 0 || process.stderr.bytesWritten !== 0;
+    const notDisabled = config.clearScreen !== false;
+    const shouldClear = notDisabled && !hasLoggedBefore;
+    return shouldClear;
+}
+function processStartupLog_onViteLog(msg, config) {
+    {
+        const isFirstVitLog = msg.includes('VITE') && msg.includes('ready');
+        if (isFirstVitLog && !globalObject.processStartupLog_hasViteLoggedStartup) {
+            globalObject.processStartupLog_hasViteLoggedStartup = true;
+            let { firstLine, isCompact } = processStartupLog(msg, config);
+            globalObject.processStartupLog_isCompact = isCompact;
+            if (!isCompact)
+                firstLine += '\n';
+            return firstLine;
+        }
+    }
+    {
+        const isViteHelpShortcutLog = msg.includes('press') && msg.includes('to show help');
+        if (isViteHelpShortcutLog && !globalObject.processStartupLog_hasViteLoggedHelpShortcut) {
+            globalObject.processStartupLog_hasViteLoggedHelpShortcut = true;
+            if (globalObject.processStartupLog_hasViteLoggedStartup && globalObject.processStartupLog_isCompact === false) {
+                return msg + '\n';
+            }
+        }
+    }
+    return msg;
+}
+function swallowViteLogForceOptimization(msg) {
+    if (!globalObject.swallowViteLogForceOptimization_enabled) {
+        return false;
+    }
+    if (msg.toLowerCase().includes('forced') && msg.toLowerCase().includes('optimization')) {
+        assert(msg === 'Forced re-optimization of dependencies', msg); // assertion fails => Vite changed its message => update this function
+        return true;
+    }
+    return false;
+}
+function swallowViteLogForceOptimization_enable() {
+    if (isDebugError())
+        return;
+    globalObject.swallowViteLogForceOptimization_enabled = true;
+}
+function swallowViteLogForceOptimization_disable() {
+    globalObject.swallowViteLogForceOptimization_enabled = false;
+}
+// Suppress "[vite] connected." message. (It doesn't go through Vite's logger thus we must monkey patch the console.log() function.)
+function swallowViteLogConnected() {
+    if (isDebugError())
+        return;
+    if (globalObject.swallowViteLogConnected_originalConsoleLog)
+        return;
+    globalObject.swallowViteLogConnected_originalConsoleLog = console.log;
+    console.log = swallowViteLogConnected_logPatch;
+    setTimeout(swallowViteLogConnected_clean, 3000);
+}
+// Remove console.log() monkey patch
+function swallowViteLogConnected_clean() {
+    // Don't remove console.log() patches from other libraries (e.g. instrumentation)
+    if (console.log === swallowViteLogConnected_logPatch)
+        return;
+    assert(globalObject.swallowViteLogConnected_originalConsoleLog);
+    console.log = globalObject.swallowViteLogConnected_originalConsoleLog;
+    globalObject.swallowViteLogConnected_originalConsoleLog = null;
+}
+function swallowViteLogConnected_logPatch(...args) {
+    const originalConsoleLog = globalObject.swallowViteLogConnected_originalConsoleLog;
+    assert(originalConsoleLog);
+    const msg = args.join(' ');
+    if (msg === '[vite] connected.') {
+        swallowViteLogConnected_clean();
+        return; // swallow
     }
+    originalConsoleLog.apply(console, args);
 }

package/dist/node/vite/shared/resolveVikeConfigInternal/transpileAndExecuteFile.d.ts

@@ -13,6 +13,7 @@ type EsbuildCache = {
     vikeConfigDependencies: Set<string>;
 };
 declare function transpileAndExecuteFile(filePath: FilePathResolved, userRootDir: string, isExtensionConfig: boolean, esbuildCache: EsbuildCache): Promise<FileExports>;
-declare function getConfigBuildErrorFormatted(err: unknown): null | string;
-declare function getConfigExecutionErrorIntroMsg(err: unknown): `Failed to transpile ${string} because:` | `Failed to execute ${string} because:` | null;
+declare function getConfigBuildErrorFormatted(err: unknown): `Failed to transpile ${string} because:
+${string}` | null;
+declare function getConfigExecutionErrorIntroMsg(err: unknown): `Failed to execute ${string} because:` | null;
 declare function isTemporaryBuildFile(filePath: string): boolean;

package/dist/node/vite/shared/resolveVikeConfigInternal/transpileAndExecuteFile.js

@@ -322,7 +322,8 @@ function getConfigBuildErrorFormatted(err) {
     if (!(formatted in err))
         return null;
     assert(typeof err[formatted] === 'string');
-    return err[formatted];
+    const errMsgFormatted = err[formatted];
+    return errMsgFormatted;
 }
 async function formatBuildErr(err, filePath) {
     assert(isObject(err) && err.errors);
@@ -333,7 +334,8 @@ async function formatBuildErr(err, filePath) {
         .map((m) => m.trim())
         .join('\n');
     const msgIntro = getErrIntroMsg('transpile', filePath);
-    err[formatted] = `${msgIntro}\n${msgEsbuild}`;
+    const errMsgFormatted = `${msgIntro}\n${msgEsbuild}`;
+    err[formatted] = errMsgFormatted;
 }
 const execErrIntroMsg = new WeakMap();
 function getConfigExecutionErrorIntroMsg(err) {

package/dist/node/vite/shared/resolveVikeConfigInternal.js

@@ -15,7 +15,7 @@ import { configDefinitionsBuiltIn, } from './resolveVikeConfigInternal/configDef
 import { getLocationId, getFilesystemRouteString, getFilesystemRouteDefinedBy, isInherited, sortAfterInheritanceOrder, applyFilesystemRoutingRootEffect, } from './resolveVikeConfigInternal/filesystemRouting.js';
 import { getViteDevServer, vikeConfigErrorRecoverMsg } from '../../../server/runtime/globalContext.js';
 import { logConfigInfo, logErrorServerDev } from './loggerDev.js';
-import { removeSuperfluousViteLog_enable, removeSuperfluousViteLog_disable, } from './loggerVite/removeSuperfluousViteLog.js';
+import { swallowViteLogForceOptimization_enable, swallowViteLogForceOptimization_disable } from './loggerVite.js';
 import pc from '@brillout/picocolors';
 import { getConfigDefinedAt, getDefinedByString, } from '../../../shared-server-client/page-configs/getConfigDefinedAt.js';
 import { loadPointerImport, loadValueFile } from './resolveVikeConfigInternal/loadFileAtConfigTime.js';
@@ -1106,7 +1106,7 @@ function resolvePrerenderContext(vikeConfig) {
 function restartViteDevServer() {
     const viteDevServer = getViteDevServer();
     assert(viteDevServer);
-    removeSuperfluousViteLog_enable();
+    swallowViteLogForceOptimization_enable();
     (async () => {
         try {
             await viteDevServer.restart(true);
@@ -1116,7 +1116,7 @@ function restartViteDevServer() {
             console.error(err);
         }
     })();
-    removeSuperfluousViteLog_disable();
+    swallowViteLogForceOptimization_disable();
 }
 function getVikeConfigDummy(esbuildCache) {
     const pageConfigsDummy = [];

package/dist/server/{runtime/onLoad.js → onLoad.js}

@@ -1,14 +1,17 @@
 export { onLoad };
-import { assertIsNotBrowser } from '../../utils/assertIsNotBrowser.js';
-import { assertNodeVersion } from '../../utils/assertNodeVersion.js';
-import { setAlwaysShowStackTrace } from '../../utils/assert.js';
+import { assertIsNotBrowser } from '../utils/assertIsNotBrowser.js';
+import { assertNodeVersion } from '../utils/assertNodeVersion.js';
+import { setAlwaysShowStackTrace } from '../utils/assert.js';
 import { installRequireShim } from '@brillout/require-shim';
-import { isDebugError } from '../../utils/debug.js';
+import { isDebugError } from '../utils/debug.js';
 function onLoad() {
     assertIsNotBrowser();
     assertNodeVersion();
-    if (isDebugError())
+    if (isDebugError()) {
+        // Is also executed upon `$ vike build` because node/vite/utils.ts imports server/utils.ts
+        Error.stackTraceLimit = Infinity;
         setAlwaysShowStackTrace();
+    }
     addEcosystemStamp();
     installRequireShim();
 }

package/dist/server/runtime/renderPageServer/addErrorHint.d.ts

@@ -1,4 +1,4 @@
 export { addErrorHint };
 export { getErrorHint };
 declare function addErrorHint(error: unknown): unknown;
-declare function getErrorHint(error: unknown): null | string;
+declare function getErrorHint(error: unknown): "The error could be a CJS/ESM issue, see https://vike.dev/broken-npm-package" | `To fix this error, see ${string}` | null;

package/dist/server/runtime/renderPageServer/addErrorHint.js

@@ -84,22 +84,18 @@ function addErrorHint(error) {
     /* Collect errors for ./addErrorHint.spec.ts
     collectError(error)
     //*/
-    let hint = getErrorHint(error);
+    const hint = getErrorHint(error);
     if (!hint)
         return error;
-    hint = formatHintLog(hint);
-    hint = pc.bold(hint);
-    let message = String(error?.message || '');
-    message = message + '\n' + hint;
-    const errBetter = getBetterError(error, { message });
-    return errBetter;
+    const append = `\n${pc.bold(formatHintLog(hint))}`;
+    return getBetterError(error, { message: { append } });
 }
 function getErrorHint(error) {
     {
         const knownErr = isKnownError(error);
         if (knownErr) {
             if (knownErr.link) {
-                return hintLinkPrefix + knownErr.link;
+                return `${hintLinkPrefix}${knownErr.link}`;
             }
             else {
                 return hintDefault;

package/dist/server/runtime/renderPageServer.js

@@ -219,8 +219,15 @@ function logHttpRequest(urlOriginal, pageContextInit, requestId) {
     const pageContext_logRuntime = getPageContext_logRuntimeEarly(pageContextInit, requestId);
     logRuntimeInfo?.(getRequestInfoMessage(urlOriginal), pageContext_logRuntime, 'info');
 }
+/*
+const arrowRight = pc.dim('>>')
+const arrowLeft = pc.dim('<<')
+/*/
+const arrowRight = pc.dim('»');
+const arrowLeft = pc.dim('«');
+//*/
 function getRequestInfoMessage(urlOriginal) {
-    return `HTTP request: ${prettyUrl(urlOriginal)}`;
+    return `HTTP request  ${arrowRight} ${prettyUrl(urlOriginal)}`;
 }
 function logHttpResponse(urlOriginalPretty, pageContextReturn) {
     const statusCode = pageContextReturn.httpResponse?.statusCode ?? null;
@@ -236,7 +243,7 @@ function logHttpResponse(urlOriginalPretty, pageContextReturn) {
             //   - We should show `HTTP response ${urlOriginalPretty} ERR` instead.
             //   - Maybe we can/should make the error available at pageContext.errorWhileRendering
             assert(errorWhileRendering === null || errorWhileRendering === undefined);
-            msg = `HTTP response ${prettyUrl(urlOriginalPretty)} ${pc.dim('null')}`;
+            msg = `HTTP response ${arrowLeft} ${prettyUrl(urlOriginalPretty)} ${pc.dim('null')}`;
             // Erroneous value (it should sometimes be `false`) but it's fine as it doesn't seem to have much of an impact.
             isNominal = true;
         }
@@ -245,7 +252,7 @@ function logHttpResponse(urlOriginalPretty, pageContextReturn) {
             isNominal = isSuccess || statusCode === 404;
             const color = (s) => pc.bold(isSuccess ? pc.green(String(s)) : pc.red(String(s)));
             const isRedirect = statusCode && 300 <= statusCode && statusCode <= 399;
-            const type = isRedirect ? 'redirect' : 'response';
+            const type = isRedirect ? 'redirect' : `response ${arrowLeft}`;
             if (isRedirect) {
                 assert(pageContextReturn.httpResponse);
                 const headerRedirect = pageContextReturn.httpResponse.headers

package/dist/server/utils.d.ts

@@ -43,6 +43,7 @@ export * from '../utils/path.js';
 export * from '../utils/isHtml.js';
 export * from '../utils/virtualFileId.js';
 export * from '../utils/colors.js';
+export * from '../utils/colorVike.js';
 export * from '../utils/getTerminalWidth.js';
 export * from '../utils/truncateString.js';
 export * from '../utils/formatHintLog.js';

package/dist/server/utils.js

@@ -1,7 +1,7 @@
 // Utils needed by Vike's server runtime
 import '../utils/trackLogs.js';
 // 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 './runtime/onLoad.js';
+import { onLoad } from './onLoad.js';
 onLoad();
 export * from '../utils/assert.js';
 export * from '../utils/cast.js';
@@ -47,6 +47,7 @@ export * from '../utils/path.js';
 export * from '../utils/isHtml.js';
 export * from '../utils/virtualFileId.js';
 export * from '../utils/colors.js';
+export * from '../utils/colorVike.js';
 export * from '../utils/getTerminalWidth.js';
 export * from '../utils/truncateString.js';
 export * from '../utils/formatHintLog.js';

package/dist/utils/PROJECT_VERSION.d.ts

@@ -1 +1 @@
-export declare const PROJECT_VERSION: "0.4.247-commit-14351e3";
+export declare const PROJECT_VERSION: "0.4.247-commit-c3d567b";

package/dist/utils/PROJECT_VERSION.js

@@ -1,2 +1,2 @@
 // Automatically updated by @brillout/release-me
-export const PROJECT_VERSION = '0.4.247-commit-14351e3';
+export const PROJECT_VERSION = '0.4.247-commit-c3d567b';

package/dist/utils/assert.js

@@ -11,6 +11,7 @@ import { assertSingleInstance_onAssertModuleLoad } from './assertSingleInstance.
 import { createErrorWithCleanStackTrace } from './createErrorWithCleanStackTrace.js';
 import { getGlobalObject } from './getGlobalObject.js';
 import { PROJECT_VERSION } from './PROJECT_VERSION.js';
+import { colorVike } from './colorVike.js';
 import pc from '@brillout/picocolors';
 const globalObject = getGlobalObject('utils/assert.ts', {
     alreadyLogged: new Set(),
@@ -20,7 +21,6 @@ const projectTag = `[vike]`;
 const projectTagWithVersion = `[vike@${PROJECT_VERSION}]`;
 const bugTag = 'Bug';
 const numberOfStackTraceLinesToRemove = 2;
-// @__NO_SIDE_EFFECTS__
 function assert(condition, debugInfo) {
     if (condition)
         return;
@@ -122,8 +122,12 @@ function addOnBeforeAssertErr(onBeforeAssertErr) {
 }
 function addPrefixAssertType(msg, tag) {
     let prefix = `[${tag}]`;
-    const color = tag === 'Warning' ? 'yellow' : 'red';
-    prefix = pc.bold(pc[color](prefix));
+    if (tag === 'Warning') {
+        prefix = pc.yellow(prefix);
+    }
+    else {
+        prefix = pc.bold(pc.red(prefix));
+    }
     return `${prefix}${msg}`;
 }
 function addWhitespace(msg) {
@@ -136,7 +140,7 @@ function addWhitespace(msg) {
 }
 function addPrefixProjectName(msg, showProjectVersion = false) {
     const prefix = showProjectVersion ? projectTagWithVersion : projectTag;
-    return `${prefix}${msg}`;
+    return `${colorVike(prefix)}${msg}`;
 }
 function isVikeBug(err) {
     return String(err).includes(`[${bugTag}]`);

package/dist/utils/colorVike.d.ts

@@ -0,0 +1,2 @@
+export { colorVike };
+declare function colorVike<Str extends string>(str: Str): Str;

package/dist/utils/colorVike.js

@@ -0,0 +1,5 @@
+export { colorVike };
+import pc from '@brillout/picocolors';
+function colorVike(str) {
+    return pc.bold(pc.yellow(str));
+}

package/dist/utils/colors.d.ts

@@ -2,6 +2,8 @@ export { stripAnsi };
 export { hasRed };
 export { hasGreen };
 export { hasYellow };
+export { colorVite };
+declare function colorVite<Str extends string>(str: Str): Str;
 declare function stripAnsi(string: string): string;
 declare function hasRed(str: string): boolean;
 declare function hasGreen(str: string): boolean;

package/dist/utils/colors.js

@@ -2,9 +2,14 @@ export { stripAnsi };
 export { hasRed };
 export { hasGreen };
 export { hasYellow };
+export { colorVite };
+import pc from '@brillout/picocolors';
 import { assertIsNotBrowser } from './assertIsNotBrowser.js';
 assertIsNotBrowser();
 const ansiRegex = getAnsiRegex();
+function colorVite(str) {
+    return pc.bold(pc.cyan(str));
+}
 // Copied from https://github.com/chalk/strip-ansi/blob/1fdc531d4046cbaa830460f5c74452bf1f0a0884/index.js
 function stripAnsi(string) {
     // Even though the regex is global, we don't need to reset the `.lastIndex`

package/dist/utils/debug.js

@@ -9,11 +9,6 @@ import { getTerminalWidth } from './getTerminalWidth.js';
 import pc from '@brillout/picocolors';
 import { isArray } from './isArray.js';
 import { isObject } from './isObject.js';
-// Assert tree-shaking (ensure this module is loaded on the client-side only if debug is enabled).
-assert(!globalThis.__VIKE__IS_CLIENT ||
-    globalThis.__VIKE__IS_DEBUG ||
-    // Vite doesn't do tree-shaking in dev (maybe it will with Rolldown?)
-    import.meta.env.DEV);
 const flags = [
     'vike',
     'vike:crawl',
@@ -36,13 +31,18 @@ const flags = [
     'vike:vite-rpc',
 ];
 const flagsSkipWildcard = ['vike:log'];
+// Assert tree-shaking (ensure this module is loaded on the client-side only if debug is enabled).
+const isUsed = !globalThis.__VIKE__IS_CLIENT ||
+    globalThis.__VIKE__IS_DEBUG ||
+    // Vite doesn't do tree-shaking in dev (maybe it will with Rolldown?)
+    import.meta.env.DEV;
 // We purposely read process.env.DEBUG early, in order to avoid users from the temptation to set process.env.DEBUG with JavaScript, since reading & writing process.env.DEBUG dynamically leads to inconsistencies such as https://github.com/vikejs/vike/issues/2239
-const DEBUG = getDEBUG() ?? '';
-if (isDebug())
-    Error.stackTraceLimit = Infinity;
-assertFlagsActivated();
+const DEBUG = (isUsed && getDEBUG()) || '';
+if (isUsed)
+    assertFlagsActivated();
 function createDebug(flag, optionsGlobal) {
     assert(flags.includes(flag));
+    assert(isUsed);
     const debugWithOptions = (optionsLocal) => {
         return (...msgs) => {
             const options = { ...optionsGlobal, ...optionsLocal };
@@ -57,6 +57,7 @@ function debug(flag, ...msgs) {
     return debug_(flag, {}, ...msgs);
 }
 function debug_(flag, options, ...msgs) {
+    assert(isUsed);
     if (!isDebug(flag))
         return;
     let [msgFirst, ...msgsRest] = msgs;
@@ -84,6 +85,7 @@ function debug_(flag, options, ...msgs) {
     });
 }
 function isDebug(flag) {
+    assert(isUsed);
     assert(flag === undefined || (flag && flags.includes(flag)));
     const { flagsActivated, isAll, isGlobal } = getFlagsActivated();
     if (flag) {
@@ -157,6 +159,7 @@ function replaceFunctionSerializer(_key, value) {
     return value;
 }
 function assertFlagsActivated() {
+    assert(isUsed);
     const { flagsActivated } = getFlagsActivated();
     flagsActivated.forEach((flag) => {
         assertUsage(flags.includes(flag), `Unknown DEBUG flag ${pc.cyan(flag)}. Valid flags:\n${flags.map((f) => `  ${pc.cyan(f)}`).join('\n')}`);
@@ -169,6 +172,7 @@ function getFlagsActivated() {
     return { flagsActivated, isAll, isGlobal };
 }
 function getDEBUG() {
+    assert(isUsed);
     let DEBUG;
     // ssr.noExternal
     /* // Full implementation:

package/dist/utils/formatHintLog.d.ts

@@ -1,2 +1,2 @@
 export { formatHintLog };
-declare function formatHintLog(msg: string): string;
+declare function formatHintLog<Msg extends string>(msg: Msg): `| ${Msg} |`;

package/dist/utils/formatHintLog.js

@@ -1,15 +1,13 @@
+export { formatHintLog };
 import { assert } from './assert.js';
 import { stripAnsi } from './colors.js';
-export { formatHintLog };
 function formatHintLog(msg) {
     assert(msg.length > 0);
     const msgLength = stripAnsi(msg).length;
     const sep = '─'.repeat(msgLength);
-    return [
-        // prettier-ignore
-        // biome-ignore format:
-        `┌─${sep}─┐`,
-        `│ ${msg} │`,
-        `└─${sep}─┘`,
-    ].join('\n');
+    const top = `┌─${sep}─┐\n`;
+    const mid = `│ ${msg} │\n`;
+    const bot = `└─${sep}─┘`;
+    const msgWrapped = `${top}${mid}${bot}`;
+    return msgWrapped;
 }

package/dist/utils/getBetterError.d.ts

@@ -1,9 +1,15 @@
 export { getBetterError };
 declare function getBetterError(err: unknown, modifications: {
-    message?: string;
+    message?: string | {
+        prepend?: string;
+        append?: string;
+    };
     stack?: string;
     hideStack?: true;
 }): {
     message: string;
     stack: string;
+    hideStack?: true;
+} & {
+    getOriginalError: () => any;
 };

package/dist/utils/getBetterError.js

@@ -1,7 +1,9 @@
 export { getBetterError };
-// TO-DO/eventually: make it a library `@brillout/better-error`
-// TODO: fix? Reprod: 7f4baa40ec95fa55319f85a38a50291460790683
+// TO-DO/maybe: make it a library `@brillout/better-error`
 import { isObject } from './isObject.js';
+import { assertIsNotBrowser } from './assertIsNotBrowser.js';
+import { objectAssign } from './objectAssign.js';
+assertIsNotBrowser();
 function getBetterError(err, modifications) {
     let errBetter;
     // Normalize
@@ -17,16 +19,42 @@ function getBetterError(err, modifications) {
         warnMalformed(err);
         errBetter.stack = new Error(errBetter.message).stack;
     }
-    if (!errBetter.stack.includes(errBetter.message)) {
-        warnMalformed(err);
+    // Modifications: err.hideStack and err.stack
+    const { message: modsMessage, ...mods } = modifications;
+    Object.assign(errBetter, mods);
+    // Modifications: err.message
+    if (typeof modsMessage === 'string') {
+        // Modify err.message
+        const messagePrev = errBetter.message;
+        const messageNext = modsMessage;
+        errBetter.message = messageNext;
+        // Update err.stack
+        const messagePrevIdx = errBetter.stack.indexOf(messagePrev);
+        if (messagePrevIdx >= 0) {
+            // Completely replace the beginning of err.stack — removing prefix such as "SyntaxError: "
+            // - Following isn't always true: `err.stack.startsWith(err.message)` — because err.stack can start with "SyntaxError: " whereas err.message doesn't
+            const stack = errBetter.stack.slice(messagePrevIdx + messagePrev.length);
+            errBetter.stack = messageNext + stack;
+        }
+        else {
+            warnMalformed(err);
+        }
+    }
+    else {
+        if (modsMessage?.append) {
+            const messagePrev = errBetter.message;
+            const messageNext = errBetter.message + modsMessage.append;
+            errBetter.message = messageNext;
+            errBetter.stack = errBetter.stack.replace(messagePrev, messageNext);
+        }
+        if (modsMessage?.prepend) {
+            const { prepend } = modsMessage;
+            errBetter.message = prepend + errBetter.message;
+            errBetter.stack = prepend + errBetter.stack;
+        }
     }
-    // Modifications
-    const errMessageOriginal = errBetter.message;
-    Object.assign(errBetter, modifications);
-    if (modifications.message)
-        errBetter.stack = errBetter.stack.replaceAll(errMessageOriginal, modifications.message);
     // Enable users to retrieve the original error
-    Object.assign(errBetter, { getOriginalError: () => err?.getOriginalError?.() ?? err });
+    objectAssign(errBetter, { getOriginalError: () => err?.getOriginalError?.() ?? err });
     return errBetter;
 }
 // TO-DO/eventually: think about whether logging this warning is a good idea

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.247-commit-14351e3",
+  "version": "0.4.247-commit-c3d567b",
   "repository": "https://github.com/vikejs/vike",
   "exports": {
     "./server": {
@@ -249,7 +249,7 @@
     "react-streaming": "^0.4.13",
     "rimraf": "^5.0.5",
     "typescript": "^5.9.3",
-    "vite": "^7.1.5"
+    "vite": "^7.2.6"
   },
   "scripts": {
     "dev": "tsc --watch",

package/dist/node/vite/shared/loggerVite/removeSuperfluousViteLog.d.ts

@@ -1,6 +0,0 @@
-export { removeSuperfluousViteLog };
-export { removeSuperfluousViteLog_enable };
-export { removeSuperfluousViteLog_disable };
-declare function removeSuperfluousViteLog(msg: string): boolean;
-declare function removeSuperfluousViteLog_enable(): void;
-declare function removeSuperfluousViteLog_disable(): void;

package/dist/node/vite/shared/loggerVite/removeSuperfluousViteLog.js

@@ -1,24 +0,0 @@
-export { removeSuperfluousViteLog };
-export { removeSuperfluousViteLog_enable };
-export { removeSuperfluousViteLog_disable };
-import { assert, getGlobalObject } from '../../utils.js';
-const globalObject = getGlobalObject('removeSuperfluousViteLog.ts', {
-    enabled: false,
-});
-const superfluousLog = 'Forced re-optimization of dependencies';
-function removeSuperfluousViteLog(msg) {
-    if (!globalObject.enabled) {
-        return false;
-    }
-    if (msg.toLowerCase().includes('forced') && msg.toLowerCase().includes('optimization')) {
-        assert(msg === superfluousLog, msg); // assertion fails => Vite changed its message => update this function
-        return true;
-    }
-    return false;
-}
-function removeSuperfluousViteLog_enable() {
-    globalObject.enabled = true;
-}
-function removeSuperfluousViteLog_disable() {
-    globalObject.enabled = false;
-}