vike 0.4.247-commit-14351e3 → 0.4.247-commit-9b74d50

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-9b74d50";

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-9b74d50';

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`