vike 0.4.247-commit-903de25 → 0.4.247-commit-14351e3

package/dist/esm/node/vite/shared/getHttpRequestAsyncStore.js

@@ -1,95 +0,0 @@
-// Purpose of this file:
-//  - Swallow redundant error messages (Vite is buggy and emits the same error multiple times)
-//  - Prepend "[request(n)]" tag to Vite logs
-// The mechanism is skipped if the development environment doesn't support Async Hooks.
-// We purposely don't use config.logger.hasErrorLogged(err) because:
-// - We don't trust Vite with such details
-//   - Example of Vite bug leading to swallowing of errors: https://github.com/vitejs/vite/issues/12631
-// - We dedupe errors ourself with getHttpRequestAsyncStore().shouldErrorBeSwallowed()
-export { getHttpRequestAsyncStore };
-export { installHttpRequestAsyncStore };
-import { renderPage_addAsyncHookwrapper } from '../../runtime/renderPage.js';
-import { assert, assertIsNotProductionRuntime, getGlobalObject, isObject, unique } from '../utils.js';
-import { getConfigBuildErrorFormatted } from './resolveVikeConfigInternal/transpileAndExecuteFile.js';
-import { logErrorDebugNote } from './loggerNotProd.js';
-import { isEquivalentErrorWithCodeSnippet } from './loggerNotProd/errorWithCodeSnippet.js';
-import { isDeepStrictEqual } from 'node:util';
-assertIsNotProductionRuntime();
-const globalObject = getGlobalObject('getHttpRequestAsyncStore.ts', {
-    asyncLocalStorage: null,
-});
-async function installHttpRequestAsyncStore() {
-    let mod;
-    try {
-        mod = await import('node:async_hooks');
-    }
-    catch {
-        return;
-    }
-    globalObject.asyncLocalStorage = new mod.AsyncLocalStorage();
-    renderPage_addAsyncHookwrapper(async (httpRequestId, renderPage) => {
-        assert(globalObject.asyncLocalStorage);
-        const loggedErrors = new Set();
-        const markErrorAsLogged = (err) => {
-            loggedErrors.add(err);
-        };
-        const shouldErrorBeSwallowed = (err) => {
-            if (loggedErrors.has(err) ||
-                Array.from(loggedErrors).some((errAlreadyLogged) => isEquivalent(err, errAlreadyLogged))) {
-                // In principle, some random message can be shown between the non-swallowed error and this logErrorDebugNote() call.
-                // We take a leap of faith that it happens only seldom and that it's worth the risk.
-                logErrorDebugNote();
-                return true;
-            }
-            else {
-                return false;
-            }
-        };
-        const store = {
-            httpRequestId,
-            markErrorAsLogged,
-            shouldErrorBeSwallowed,
-            errorDebugNoteAlreadyShown: false,
-        };
-        const pageContextReturn = await globalObject.asyncLocalStorage.run(store, renderPage);
-        return { pageContextReturn };
-    });
-    return;
-}
-function getHttpRequestAsyncStore() {
-    if (globalObject.asyncLocalStorage === null)
-        return null;
-    const store = globalObject.asyncLocalStorage.getStore();
-    assert(store === undefined || isObject(store));
-    return store;
-}
-function isEquivalent(err1, err2) {
-    if (err1 === err2)
-        return true;
-    if (!isObject(err1) || !isObject(err2))
-        return false;
-    {
-        const errMsgFormatted1 = getConfigBuildErrorFormatted(err1);
-        const errMsgFormatted2 = getConfigBuildErrorFormatted(err2);
-        if (errMsgFormatted1 && errMsgFormatted1 === errMsgFormatted2)
-            return true;
-    }
-    if (isEquivalentErrorWithCodeSnippet(err1, err2))
-        return true;
-    if (unique([
-        // error.message and error.stack aren't enumerable and therefore not listed by Object.keys()
-        'message',
-        'stack',
-        ...Object.keys(err1),
-        ...Object.keys(err2),
-    ]).every((k) => {
-        // isDeepStrictEqual() need to compare error.position which is an object.
-        if (isDeepStrictEqual(err1[k], err2[k]))
-            return true;
-        // console.log('diff', k)
-        return false;
-    })) {
-        return true;
-    }
-    return false;
-}

package/dist/esm/node/vite/shared/getOutDirs.js

@@ -1,141 +0,0 @@
-export { getOutDirs };
-export { resolveOutDir };
-import pc from '@brillout/picocolors';
-import { assert, assertPosixPath, assertUsage, createDebugger, pathJoin, toPosixPath } from '../utils.js';
-import { isViteServerSide_viteEnvOptional } from './isViteServerSide.js';
-const debug = createDebugger('vike:outDir');
-function getOutDirs(configGlobal, viteEnv) {
-    debug('getOutDirs()', new Error().stack);
-    const outDir = getOutDirFromResolvedConfig(configGlobal, viteEnv);
-    assertOutDirResolved(outDir, configGlobal, viteEnv);
-    const outDirs = getOutDirsAll(outDir, configGlobal.root);
-    assertNormalization(outDirs.outDirRoot);
-    assertNormalization(outDirs.outDirClient);
-    assertNormalization(outDirs.outDirServer);
-    return outDirs;
-}
-/** Appends `client/` or `server/` to `config.build.outDir` */
-function resolveOutDir(config, isServerSide) {
-    debug('resolveOutDir()');
-    const outDir = getOutDirFromViteUserConfig(config) || 'dist';
-    debug('outDir', outDir);
-    const { outDirClient, outDirServer } = getOutDirsAll(outDir);
-    if (isServerSide) {
-        debug('outDirServer', 'outDirServer');
-        return outDirServer;
-    }
-    else {
-        debug('outDirClient', 'outDirClient');
-        return outDirClient;
-    }
-}
-function determineOutDirs(outDirRoot) {
-    assertPosixPath(outDirRoot);
-    assert(isOutDirRoot(outDirRoot));
-    const outDirClient = pathJoin(outDirRoot, 'client');
-    const outDirServer = pathJoin(outDirRoot, 'server');
-    assertIsNotOutDirRoot(outDirClient);
-    assertIsNotOutDirRoot(outDirServer);
-    return { outDirClient, outDirServer };
-}
-function getOutDirsAll(outDir, root) {
-    let outDirRoot;
-    {
-        if (isOutDirRoot(outDir)) {
-            outDirRoot = outDir;
-        }
-        else {
-            assert(outDir.endsWith('/server') || outDir.endsWith('/client'));
-            assert('/client'.length === '/server'.length);
-            outDirRoot = outDir.slice(0, -1 * '/client'.length);
-        }
-    }
-    debug('outDirRoot', outDirRoot);
-    let outDirs;
-    if (root) {
-        outDirs = getOutDirsAllFromRootNormalized(outDirRoot, root);
-    }
-    else {
-        outDirs = getOutDirsAllFromRoot(outDirRoot);
-    }
-    debug('outDirs', outDirs);
-    return outDirs;
-}
-function getOutDirsAllFromRoot(outDirRoot) {
-    let { outDirClient, outDirServer } = determineOutDirs(outDirRoot);
-    return { outDirRoot, outDirClient, outDirServer };
-}
-function getOutDirsAllFromRootNormalized(outDirRoot, root) {
-    if (root && !outDirIsAbsolutePath(outDirRoot)) {
-        assertPosixPath(outDirRoot);
-        assertPosixPath(root);
-        outDirRoot = pathJoin(root, outDirRoot);
-    }
-    let { outDirClient, outDirServer } = determineOutDirs(outDirRoot);
-    outDirRoot = outDirRoot + '/';
-    outDirClient = outDirClient + '/';
-    outDirServer = outDirServer + '/';
-    assertNormalization(outDirRoot);
-    assertNormalization(outDirClient);
-    assertNormalization(outDirServer);
-    return { outDirRoot, outDirClient, outDirServer };
-}
-function assertNormalization(outDirAny) {
-    assertPosixPath(outDirAny);
-    assert(outDirIsAbsolutePath(outDirAny), outDirAny);
-    assert(outDirAny.endsWith('/'), outDirAny);
-    assert(!outDirAny.endsWith('//'), outDirAny);
-}
-function isOutDirRoot(outDirRot) {
-    const p = outDirRot.split('/').filter(Boolean);
-    const lastDir = p[p.length - 1];
-    return lastDir !== 'client' && lastDir !== 'server';
-}
-function assertIsNotOutDirRoot(outDir) {
-    assert(outDir.endsWith('/client') || outDir.endsWith('/server'));
-}
-/** Assert that `outDir` ends with the correct directory `/server` or `/client` */
-function assertOutDirResolved(outDir, configGlobal, viteEnv) {
-    assertPosixPath(outDir);
-    if (isOutDirRoot(outDir))
-        return;
-    assert(outDir.endsWith('/client') || outDir.endsWith('/server')); // we normalized outDir
-    assert('/client'.length === '/server'.length);
-    const outDirCorrected = outDir.slice(0, -1 * '/client'.length);
-    const wrongUsage = `You've set Vite's config.build.outDir to ${pc.cyan(outDir)} but you should set it to ${pc.cyan(outDirCorrected)} instead.`;
-    const isServerSide = isViteServerSide_viteEnvOptional(configGlobal, viteEnv);
-    if (isServerSide) {
-        assertUsage(outDir.endsWith('/server'), wrongUsage);
-    }
-    else {
-        assertUsage(outDir.endsWith('/client'), wrongUsage);
-    }
-}
-function getOutDirFromViteUserConfig(config) {
-    let outDir = config.build?.outDir;
-    if (outDir === undefined)
-        return undefined;
-    outDir = normalizeOutDir(outDir);
-    return outDir;
-}
-function getOutDirFromResolvedConfig(config, viteEnv) {
-    let outDir = viteEnv?.config.build?.outDir ?? config.build.outDir;
-    assert(outDir);
-    outDir = normalizeOutDir(outDir);
-    return outDir;
-}
-function normalizeOutDir(outDir) {
-    outDir = toPosixPath(outDir);
-    outDir = outDir.replace(/\/+$/, ''); // remove trailing slashes
-    return outDir;
-}
-function outDirIsAbsolutePath(outDir) {
-    // There doesn't seem to be a better alternative to determine whether `outDir` is an absolute path
-    //  - Very unlikely that `outDir`'s first dir matches the filesystem's first dir
-    //    - Although more likely to happen with Docker
-    return getFirstDir(outDir) === getFirstDir(process.cwd());
-}
-function getFirstDir(p) {
-    const firstDir = p.split(/\/|\\/).filter(Boolean)[0];
-    return firstDir;
-}

package/dist/esm/node/vite/shared/isViteServerSide.js

@@ -1,75 +0,0 @@
-export { isViteServerSide };
-export { isViteServerSide_viteEnvOptional };
-export { isViteServerSide_onlySsrEnv };
-export { isViteServerSide_extraSafe };
-export { isViteServerSide_applyToEnvironment };
-export { isViteServerSide_configEnvironment };
-import { assert } from '../../../utils/assert.js';
-function isViteServerSide_impl(configGlobal, viteEnv) {
-    assert(!('consumer' in configGlobal)); // make sure configGlobal isn't viteEnv.config
-    const debug = {
-        viteEnvIsUndefined: !viteEnv,
-        viteEnvName: viteEnv?.name ?? null,
-        viteEnvConsumer: viteEnv?.config.consumer ?? null,
-        configEnvBuildSsr: viteEnv?.config.build?.ssr ?? null,
-        configGlobalBuildSsr: configGlobal.build?.ssr ?? null,
-    };
-    if (!viteEnv) {
-        const isServerSide = getBuildSsrValue(configGlobal.build?.ssr);
-        assert(typeof isServerSide === 'boolean', debug);
-        return isServerSide;
-    }
-    else {
-        const isServerSide1 = !viteEnv.config.consumer ? null : viteEnv.config.consumer !== 'client';
-        const isServerSide2 = getBuildSsrValue(viteEnv.config.build?.ssr);
-        const isServerSide3 = viteEnv.name === 'ssr' ? true : viteEnv.name === 'client' ? false : null;
-        const isServerSide = isServerSide1 ?? isServerSide2;
-        assert(isServerSide === isServerSide1 || isServerSide1 === null, debug);
-        assert(isServerSide === isServerSide2 || isServerSide2 === null, debug);
-        assert(isServerSide === isServerSide3 || isServerSide3 === null, debug);
-        assert(isServerSide !== null);
-        return isServerSide;
-    }
-}
-function getBuildSsrValue(buildSsr) {
-    if (buildSsr === undefined)
-        return null;
-    assert(typeof buildSsr === 'boolean' || typeof buildSsr === 'string');
-    return !!buildSsr;
-}
-function isViteServerSide(configGlobal, viteEnv) {
-    return isViteServerSide_impl(configGlobal, viteEnv);
-}
-function isViteServerSide_viteEnvOptional(configGlobal, viteEnv) {
-    return isViteServerSide_impl(configGlobal, viteEnv);
-}
-// Only `ssr` env: for example don't include `vercel_edge` nor `vercel_node`.
-function isViteServerSide_onlySsrEnv(configGlobal, viteEnv) {
-    return viteEnv.name ? viteEnv.name === 'ssr' : isViteServerSide(configGlobal, viteEnv);
-}
-// Vite is quite messy about setting config.build.ssr — for security purposes, we use an extra safe implementation with lots of assertions, which is needed for the .client.js and .server.js guarantee.
-function isViteServerSide_extraSafe(config, viteEnv, options) {
-    const isServerSide = isViteServerSide(config, viteEnv);
-    const debug = {
-        isServerSide,
-        configCommand: config.command,
-        configBuildSsr: getBuildSsrValue(config.build.ssr),
-        optionsIsUndefined: options === undefined,
-        optionsSsr: options?.ssr ?? null,
-    };
-    assert(options, debug);
-    assert(typeof options.ssr === 'boolean', debug);
-    assert(options.ssr === isServerSide, debug);
-    return isServerSide;
-}
-function isViteServerSide_applyToEnvironment(env) {
-    const { consumer } = env.config;
-    return isViteServerSide_consumer(consumer);
-}
-function isViteServerSide_configEnvironment(name, config) {
-    const consumer = config.consumer ?? (name === 'client' ? 'client' : 'server');
-    return isViteServerSide_consumer(consumer);
-}
-function isViteServerSide_consumer(consumer) {
-    return consumer !== 'client';
-}

package/dist/esm/node/vite/shared/loggerNotProd/log.d.ts

@@ -1,9 +0,0 @@
-export { logWithViteTag };
-export { logWithVikeTag };
-export { logDirectly };
-export { applyViteSourceMapToStackTrace };
-import type { LogCategory, LogType } from '../loggerNotProd.js';
-declare function logWithVikeTag(msg: string, logType: LogType, category: LogCategory | null, showVikeVersion?: boolean): void;
-declare function logWithViteTag(msg: string, logType: LogType, category: LogCategory | null): void;
-declare function logDirectly(thing: unknown, logType: LogType): void;
-declare function applyViteSourceMapToStackTrace(thing: unknown): void;

package/dist/esm/node/vite/shared/loggerNotProd/log.js

@@ -1,103 +0,0 @@
-export { logWithViteTag };
-export { logWithVikeTag };
-export { logDirectly };
-export { applyViteSourceMapToStackTrace };
-import { assert, stripAnsi, hasProp, assertIsNotProductionRuntime, PROJECT_VERSION } from '../../utils.js';
-import pc from '@brillout/picocolors';
-import { isErrorDebug } from '../../../shared/isErrorDebug.js';
-import { getViteDevServer } from '../../../runtime/globalContext.js';
-import { logErrorServer } from '../../../runtime/logErrorServer.js';
-assertIsNotProductionRuntime();
-function logWithVikeTag(msg, logType, category, showVikeVersion = false) {
-    const projectTag = getProjectTag(showVikeVersion);
-    msg = prependTags(msg, projectTag, category, logType);
-    logDirectly(msg, logType);
-}
-function getProjectTag(showVikeVersion) {
-    let projectTag;
-    if (showVikeVersion) {
-        projectTag = `[vike@${PROJECT_VERSION}]`;
-    }
-    else {
-        projectTag = `[vike]`;
-    }
-    return projectTag;
-}
-function logWithViteTag(msg, logType, category) {
-    msg = prependTags(msg, '[vite]', category, logType);
-    logDirectly(msg, logType);
-}
-// Not production => every log is triggered by logDirectly()
-//  - Even all Vite logs also go through logDirectly() (see interceptors of loggerVite.ts)
-//  - Production => logs aren't managed by loggerNotProd.ts => logDirectly() is never called (not even loaded as asserted by assertIsVitePluginCode())
-function logDirectly(thing, logType) {
-    applyViteSourceMapToStackTrace(thing);
-    if (logType === 'info') {
-        console.log(thing);
-        return;
-    }
-    if (logType === 'warn') {
-        console.warn(thing);
-        return;
-    }
-    if (logType === 'error-note') {
-        console.error(thing);
-        return;
-    }
-    if (logType === 'error-thrown') {
-        // console.error()
-        logErrorServer(thing);
-        return;
-    }
-    if (logType === 'error-recover') {
-        // stderr because user will most likely want to know about error recovering
-        console.error(thing);
-        return;
-    }
-    assert(false);
-}
-function applyViteSourceMapToStackTrace(thing) {
-    if (isErrorDebug())
-        return;
-    if (!hasProp(thing, 'stack'))
-        return;
-    const viteDevServer = getViteDevServer();
-    if (!viteDevServer)
-        return;
-    // Apply Vite's source maps
-    viteDevServer.ssrFixStacktrace(thing);
-}
-function prependTags(msg, projectTag, category, logType) {
-    const color = (s) => {
-        if (logType === 'error-thrown' && !hasRed(msg))
-            return pc.bold(pc.red(s));
-        if (logType === 'error-recover' && !hasGreen(msg))
-            return pc.bold(pc.green(s));
-        if (logType === 'warn' && !hasYellow(msg))
-            return pc.yellow(s);
-        if (projectTag === '[vite]')
-            return pc.bold(pc.cyan(s));
-        if (projectTag.startsWith(`[vike`))
-            return pc.bold(pc.cyan(s));
-        assert(false);
-    };
-    let tag = color(`${projectTag}`);
-    if (category) {
-        tag = tag + pc.dim(`[${category}]`);
-    }
-    const timestamp = pc.dim(new Date().toLocaleTimeString());
-    const whitespace = /\s|\[/.test(stripAnsi(msg)[0]) ? '' : ' ';
-    return `${timestamp} ${tag}${whitespace}${msg}`;
-}
-function hasRed(str) {
-    // https://github.com/brillout/picocolors/blob/e291f2a3e3251a7f218ab6369ae94434d85d0eb0/picocolors.js#L57
-    return str.includes('\x1b[31m');
-}
-function hasGreen(str) {
-    // https://github.com/brillout/picocolors/blob/e291f2a3e3251a7f218ab6369ae94434d85d0eb0/picocolors.js#L58
-    return str.includes('\x1b[32m');
-}
-function hasYellow(str) {
-    // https://github.com/brillout/picocolors/blob/e291f2a3e3251a7f218ab6369ae94434d85d0eb0/picocolors.js#L59
-    return str.includes('\x1b[33m');
-}

package/dist/esm/node/vite/shared/loggerNotProd.d.ts

@@ -1,30 +0,0 @@
-export { logViteAny };
-export { logViteError };
-export { logConfigInfo };
-export { logConfigError };
-export { logConfigErrorRecover };
-export { logErrorDebugNote };
-export type { LogInfo };
-export type { LogInfoArgs };
-export type { LogError };
-export type { LogErrorArgs };
-export type { LogType };
-export type { LogCategory };
-type LogType = 'info' | 'warn' | 'error-thrown' | 'error-recover' | 'error-note';
-type LogCategory = 'config' | `request(${number})`;
-type LogInfo = (...args: LogInfoArgs) => void;
-type LogInfoArgs = Parameters<typeof logRuntimeInfo>;
-type LogError = (...args: LogErrorArgs) => void;
-type LogErrorArgs = Parameters<typeof logRuntimeError>;
-declare function logRuntimeInfo(msg: string, httpRequestId: number | null, logType: LogType): void;
-declare function logViteAny(msg: string, logType: LogType, httpRequestId: number | null, prependViteTag: boolean): void;
-declare function logConfigInfo(msg: string, logType: LogType): void;
-declare function logConfigErrorRecover(): void;
-declare function logRuntimeError(err: unknown, httpRequestId: number | null): void;
-declare function logViteError(err: unknown, httpRequestId: number | undefined): void;
-declare function logConfigError(err: unknown): void;
-/** Note shown to user when vike does something risky:
- *  - When vike dedupes (i.e. swallows) an error with getHttpRequestAsyncStore().shouldErrorBeSwallowed(err)
- *  - When vike modifies the error with getPrettyErrorWithCodeSnippet(err)
- */
-declare function logErrorDebugNote(): void;

package/dist/esm/node/vite/shared/loggerNotProd.js

@@ -1,209 +0,0 @@
-// TO-DO/eventually:
-// - New hook onLog(): https://github.com/vikejs/vike/issues/1438
-// - Exact same logs between prod and dev, only difference is that some log objects have:
-//   - `isDevLog: true`
-//   - `willBeLogged: false` in production
-//   - `showTimestamp: true`
-// - Never clear screen (it's complex with little benefit)
-//   - Add shortcut to clear screen
-//   - Maybe rotate colors upon no requests within 30s?
-// - Only show a one-liner init log (instead of Vite's multi-line log)
-// Non-production logger used for:
-//  - Development
-//  - Preview
-//  - Build
-//  - Pre-rendering
-// In other words: everywhere except in production
-export { logViteAny };
-export { logViteError };
-export { logConfigInfo };
-export { logConfigError };
-export { logConfigErrorRecover };
-export { logErrorDebugNote };
-import { isAbortError } from '../../../shared/route/abort.js';
-import { getViteConfig, vikeConfigErrorRecoverMsg } from '../../runtime/globalContext.js';
-import { overwriteRuntimeProductionLogger } from '../../runtime/loggerRuntime.js';
-import { assert, assertIsNotProductionRuntime, formatHintLog, getAssertErrMsg, overwriteAssertProductionLogger, stripAnsi, warnIfErrorIsNotObject, } from '../utils.js';
-import { getHttpRequestAsyncStore } from './getHttpRequestAsyncStore.js';
-import { isErrorDebug } from '../../shared/isErrorDebug.js';
-import { isErrorWithCodeSnippet, getPrettyErrorWithCodeSnippet } from './loggerNotProd/errorWithCodeSnippet.js';
-import { getConfigExecutionErrorIntroMsg, getConfigBuildErrorFormatted, } from './resolveVikeConfigInternal/transpileAndExecuteFile.js';
-import { logWithVikeTag, logWithViteTag, logDirectly, applyViteSourceMapToStackTrace } from './loggerNotProd/log.js';
-import pc from '@brillout/picocolors';
-import { setAlreadyLogged } from '../../runtime/renderPage/isNewError.js';
-import { onRuntimeError } from '../../runtime/renderPage/loggerProd.js';
-import { isUserHookError } from '../../../shared/hooks/execHook.js';
-assertIsNotProductionRuntime();
-overwriteRuntimeProductionLogger(logRuntimeError, logRuntimeInfo);
-overwriteAssertProductionLogger(assertLogger);
-function logRuntimeInfo(msg, httpRequestId, logType) {
-    const category = getCategory(httpRequestId);
-    logWithVikeTag(msg, logType, category);
-}
-function logViteAny(msg, logType, httpRequestId, prependViteTag) {
-    if (prependViteTag) {
-        const category = getCategory(httpRequestId);
-        logWithViteTag(msg, logType, category);
-    }
-    else {
-        logDirectly(msg, logType);
-    }
-}
-function logConfigInfo(msg, logType) {
-    const category = getConfigCategory();
-    logWithVikeTag(msg, logType, category);
-}
-function logConfigErrorRecover() {
-    const category = getConfigCategory();
-    logWithVikeTag(vikeConfigErrorRecoverMsg, 'error-recover', category);
-}
-function logRuntimeError(err, 
-// httpRequestId is `null` when pre-rendering
-httpRequestId) {
-    logErr(err, httpRequestId, false);
-}
-function logViteError(err, 
-// httpRequestId is `undefined` if development environment doesn't support async stores
-httpRequestId) {
-    logErr(err, httpRequestId, true);
-}
-function logErr(err, httpRequestId = null, errorComesFromVite) {
-    warnIfErrorIsNotObject(err);
-    if (isAbortError(err) && !isErrorDebug()) {
-        return;
-    }
-    const store = getHttpRequestAsyncStore();
-    setAlreadyLogged(err);
-    if (getHttpRequestAsyncStore()?.shouldErrorBeSwallowed(err)) {
-        if (!isErrorDebug())
-            return;
-    }
-    else {
-        store?.markErrorAsLogged(err);
-    }
-    const category = getCategory(httpRequestId);
-    if (!isErrorDebug()) {
-        if (isErrorWithCodeSnippet(err)) {
-            // 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);
-            const prettyErr = getPrettyErrorWithCodeSnippet(err, viteConfig.root);
-            assert(stripAnsi(prettyErr).startsWith('Failed to transpile'));
-            logWithViteTag(prettyErr, 'error-thrown', category);
-            logErrorDebugNote();
-            return;
-        }
-        {
-            const logged = handleAssertMsg(err, category);
-            if (logged)
-                return;
-        }
-    }
-    // Needs to be after assertion messages handling, because user hooks may throw an assertion error
-    const hook = isUserHookError(err);
-    if (hook) {
-        const { hookName, hookFilePath } = hook;
-        logWithVikeTag(pc.red(`Following error was thrown by the ${hookName}() hook defined at ${hookFilePath}`), 'error-note', category);
-    }
-    else if (category) {
-        logFallbackErrIntro(category, errorComesFromVite);
-    }
-    logDirectly(err, 'error-thrown');
-    // Needs to be called after logging the error.
-    onRuntimeError(err);
-}
-function logConfigError(err) {
-    warnIfErrorIsNotObject(err);
-    const category = getConfigCategory();
-    {
-        const errIntroMsg = getConfigExecutionErrorIntroMsg(err);
-        if (errIntroMsg) {
-            assert(stripAnsi(errIntroMsg).startsWith('Failed to execute'));
-            logWithVikeTag(errIntroMsg, 'error-note', category);
-            logDirectly(err, 'error-thrown');
-            return;
-        }
-    }
-    {
-        const errMsgFormatted = getConfigBuildErrorFormatted(err);
-        if (errMsgFormatted) {
-            assert(stripAnsi(errMsgFormatted).startsWith('Failed to transpile'));
-            if (!isErrorDebug()) {
-                logWithVikeTag(errMsgFormatted, 'error-thrown', category);
-            }
-            else {
-                logDirectly(err, 'error-thrown');
-            }
-            return;
-        }
-    }
-    {
-        const logged = handleAssertMsg(err, category);
-        if (logged)
-            return;
-    }
-    if (category)
-        logFallbackErrIntro(category, false);
-    logDirectly(err, 'error-thrown');
-}
-function logFallbackErrIntro(category, errorComesFromVite) {
-    const msg = errorComesFromVite ? 'Transpilation error' : 'An error was thrown';
-    logWithVikeTag(pc.bold(pc.red(`[Error] ${msg}:`)), 'error-note', category);
-}
-function getConfigCategory() {
-    const category = getCategory() ?? 'config';
-    return category;
-}
-function handleAssertMsg(err, category) {
-    const res = getAssertErrMsg(err);
-    if (!res)
-        return false;
-    const { assertMsg, showVikeVersion } = res;
-    logWithVikeTag(assertMsg, 'error-thrown', category, showVikeVersion);
-    return true;
-}
-function assertLogger(thing, logType) {
-    // vite.ssrFixStacktrace() is needed for `assertWarning(..., { showStackTrace: true })`
-    applyViteSourceMapToStackTrace(thing);
-    const category = getCategory();
-    const res = getAssertErrMsg(thing);
-    /* Risk of infinite loop
-    assert(res)
-    */
-    if (!res)
-        throw new Error('Internal Vike error, reach out to a maintainer');
-    const { assertMsg, showVikeVersion } = res;
-    logWithVikeTag(assertMsg, logType, category, showVikeVersion);
-}
-/** Note shown to user when vike does something risky:
- *  - When vike dedupes (i.e. swallows) an error with getHttpRequestAsyncStore().shouldErrorBeSwallowed(err)
- *  - When vike modifies the error with getPrettyErrorWithCodeSnippet(err)
- */
-function logErrorDebugNote() {
-    if (isErrorDebug())
-        return;
-    const store = getHttpRequestAsyncStore();
-    if (store) {
-        if (store.errorDebugNoteAlreadyShown)
-            return;
-        store.errorDebugNoteAlreadyShown = true;
-    }
-    const msg = pc.dim(formatHintLog("Error isn't helpful? See https://vike.dev/debug#verbose-errors"));
-    logDirectly(msg, 'error-note');
-}
-function getCategory(httpRequestId = null) {
-    const store = getHttpRequestAsyncStore();
-    if (store?.httpRequestId !== undefined) {
-        if (httpRequestId === null) {
-            httpRequestId = store.httpRequestId;
-        }
-        else {
-            assert(httpRequestId === store.httpRequestId);
-        }
-    }
-    if (httpRequestId === null)
-        return null;
-    // const category = httpRequestId % 2 === 1 ? (`request-${httpRequestId}` as const) : (`request(${httpRequestId})` as const)
-    const category = `request(${httpRequestId})`;
-    return category;
-}