vike 0.4.240 → 0.4.241-commit-60b0676

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

@@ -0,0 +1,207 @@
+export { resolveViteConfigFromUser };
+export { isOnlyResolvingUserConfig };
+export { getVikeConfigInternalEarly };
+export { getViteContextWithOperation };
+export { getViteRoot };
+export { assertViteRoot };
+export { normalizeViteRoot };
+import { loadConfigFromFile, mergeConfig, resolveConfig } from 'vite';
+import { getVikeConfigInternal, getVikeConfigFromCliOrEnv, setVikeConfigContext, isVikeConfigContextSet, } from '../vite/shared/resolveVikeConfigInternal.js';
+import path from 'node:path';
+import { assert, assertUsage, assertWarning, getGlobalObject, pick, toPosixPath } from './utils.js';
+import pc from '@brillout/picocolors';
+import { getEnvVarObject } from '../vite/shared/getEnvVarObject.js';
+import { getVikeApiOperation, isVikeCliOrApi } from './context.js';
+import { getViteCommandFromCli } from '../vite/shared/isViteCli.js';
+const globalObject = getGlobalObject('api/prepareViteApiCall.ts', {});
+async function resolveViteConfigFromUser(viteConfigFromUserVikeApiOptions, viteContext) {
+    const viteInfo = await getViteInfo(viteConfigFromUserVikeApiOptions, viteContext);
+    setVikeConfigContext_(viteInfo, viteContext);
+    const { viteConfigFromUserResolved } = viteInfo;
+    const { viteConfigResolved } = await assertViteRoot2(viteInfo.root, viteConfigFromUserResolved, viteContext);
+    return {
+        viteConfigResolved, // ONLY USE if strictly necessary. (We plan to remove assertViteRoot2() as explained in the comments of that function.)
+        viteConfigFromUserResolved,
+    };
+}
+async function getVikeConfigInternalEarly() {
+    assert(!globalObject.isOnlyResolvingUserConfig); // ensure no infinite loop
+    if (!isVikeConfigContextSet()) {
+        const viteContext = getViteContext();
+        const viteInfo = await getViteInfo(undefined, viteContext);
+        setVikeConfigContext_(viteInfo, viteContext);
+    }
+    return await getVikeConfigInternal();
+}
+function setVikeConfigContext_(viteInfo, viteContext) {
+    setVikeConfigContext({
+        userRootDir: viteInfo.root,
+        isDev: viteContext === 'dev',
+        vikeVitePluginOptions: viteInfo.vikeVitePluginOptions,
+    });
+}
+function isOnlyResolvingUserConfig() {
+    return globalObject.isOnlyResolvingUserConfig;
+}
+async function getViteRoot(viteContext) {
+    if (!globalObject.root)
+        await getViteInfo(undefined, viteContext);
+    assert(globalObject.root);
+    return globalObject.root;
+}
+async function getViteInfo(viteConfigFromUserVikeApiOptions, viteContext) {
+    let viteConfigFromUserResolved = viteConfigFromUserVikeApiOptions;
+    // Precedence:
+    //  1) viteConfigFromUserEnvVar (highest precedence)
+    //  2) viteConfigFromUserVikeConfig
+    //  2) viteConfigFromUserVikeApiOptions
+    //  3) viteConfigFromUserViteFile (lowest precedence)
+    // Resolve Vike's +mode setting
+    {
+        const viteConfigFromUserVikeConfig = pick(getVikeConfigFromCliOrEnv().vikeConfigFromCliOrEnv, ['mode']);
+        if (Object.keys(viteConfigFromUserVikeConfig).length > 0) {
+            viteConfigFromUserResolved = mergeConfig(viteConfigFromUserResolved ?? {}, viteConfigFromUserVikeConfig);
+        }
+    }
+    // Resolve VITE_CONFIG
+    const viteConfigFromUserEnvVar = getEnvVarObject('VITE_CONFIG');
+    if (viteConfigFromUserEnvVar) {
+        viteConfigFromUserResolved = mergeConfig(viteConfigFromUserResolved ?? {}, viteConfigFromUserEnvVar);
+    }
+    // Resolve vite.config.js
+    globalObject.isOnlyResolvingUserConfig = true;
+    const viteConfigFromUserViteConfigFile = await loadViteConfigFile(viteConfigFromUserResolved, viteContext);
+    globalObject.isOnlyResolvingUserConfig = false;
+    // Correct precedence, replicates Vite:
+    // https://github.com/vitejs/vite/blob/4f5845a3182fc950eb9cd76d7161698383113b18/packages/vite/src/node/config.ts#L1001
+    const viteConfigResolved = mergeConfig(viteConfigFromUserViteConfigFile ?? {}, viteConfigFromUserResolved ?? {});
+    const root = normalizeViteRoot(viteConfigResolved.root ?? process.cwd());
+    globalObject.root = root;
+    // - Find options `vike(options)` set in vite.config.js
+    //   - TO-DO/next-major-release: remove
+    // - Add Vike's Vite plugin if missing
+    let vikeVitePluginOptions;
+    const found = findVikeVitePlugin(viteConfigResolved);
+    if (found) {
+        vikeVitePluginOptions = found.vikeVitePluginOptions;
+    }
+    else {
+        // Show a warning because Vike supports Vite's CLI (as well as third-party CLIs).
+        // - Encourage users to define a vite.config.js file that also works with Vite's CLI (and potentially other third-party CLIs).
+        // - Vike-based frameworks, such as DocPress, allow their users to omit defining a vite.config.js file.
+        assertWarning(viteConfigFromUserViteConfigFile, // Only show the warning if the user defined a vite.config.js file
+        "Omitting Vike's Vite plugin (inside your vite.config.js) is deprecated — make sure to always add Vike's Vite plugin https://vike.dev/vite-plugin", { onlyOnce: true });
+        // Add Vike to plugins if not present.
+        // Using a dynamic import because the script calling the Vike API may not live in the same place as vite.config.js, thus vike/plugin may resolved to two different node_modules/vike directories.
+        const { plugin: vikePlugin } = await import('../vite/index.js');
+        viteConfigFromUserResolved = {
+            ...viteConfigFromUserResolved,
+            plugins: [...(viteConfigFromUserResolved?.plugins ?? []), vikePlugin()],
+        };
+        const res = findVikeVitePlugin(viteConfigFromUserResolved);
+        assert(res);
+        vikeVitePluginOptions = res.vikeVitePluginOptions;
+    }
+    assert(vikeVitePluginOptions);
+    return { root, vikeVitePluginOptions, viteConfigFromUserResolved };
+}
+function findVikeVitePlugin(viteConfig) {
+    let vikeVitePluginOptions;
+    let vikeVitePuginFound = false;
+    viteConfig?.plugins?.forEach((p) => {
+        if (p && '_vikeVitePluginOptions' in p) {
+            vikeVitePuginFound = true;
+            const options = p._vikeVitePluginOptions;
+            vikeVitePluginOptions ?? (vikeVitePluginOptions = {});
+            Object.assign(vikeVitePluginOptions, options);
+        }
+    });
+    if (!vikeVitePuginFound)
+        return null;
+    return { vikeVitePluginOptions };
+}
+// Copied from https://github.com/vitejs/vite/blob/4f5845a3182fc950eb9cd76d7161698383113b18/packages/vite/src/node/config.ts#L961-L1005
+async function loadViteConfigFile(viteConfigFromUserResolved, viteContext) {
+    const viteContextResolved = resolveViteContext(viteConfigFromUserResolved, viteContext);
+    const [inlineConfig, command, defaultMode, _defaultNodeEnv, isPreview] = viteContextResolved;
+    let config = inlineConfig;
+    let mode = inlineConfig.mode || defaultMode;
+    const configEnv = {
+        mode,
+        command,
+        isSsrBuild: command === 'build' && !!config.build?.ssr,
+        isPreview,
+    };
+    let { configFile } = config;
+    if (configFile !== false) {
+        const loadResult = await loadConfigFromFile(configEnv, configFile, config.root, config.logLevel, config.customLogger);
+        if (!loadResult)
+            return null;
+        assert(loadResult.config);
+        return loadResult.config;
+    }
+    return null;
+}
+function getViteContext() {
+    const vikeApiOperation = getVikeApiOperation();
+    const viteCommand = getViteCommandFromCli();
+    assert(!(viteCommand && vikeApiOperation));
+    if (vikeApiOperation)
+        return getViteContextWithOperation(vikeApiOperation.operation);
+    assert(!isVikeCliOrApi());
+    if (viteCommand === 'dev' || viteCommand === 'optimize') {
+        return 'dev';
+    }
+    if (viteCommand === 'build') {
+        return 'build';
+    }
+    if (viteCommand === 'preview') {
+        return 'preview';
+    }
+    // Third-party CLIs.
+    // - Component development (e.g. Storybook) => let's consider it development
+    // - Testing (e.g. Vitest) => let's consider it development
+    return 'dev';
+}
+function getViteContextWithOperation(operation) {
+    if (operation === 'build' || operation === 'prerender') {
+        return 'build';
+    }
+    if (operation === 'preview') {
+        return 'preview';
+    }
+    if (operation === 'dev') {
+        return 'dev';
+    }
+    assert(false);
+}
+function resolveViteContext(inlineConfig = {}, viteContext) {
+    const isBuild = viteContext === 'build';
+    const isPreview = viteContext === 'preview';
+    const isDev = viteContext === 'dev';
+    const command = isBuild ? 'build' : 'serve';
+    const defaultMode = isDev ? 'development' : 'production';
+    const defaultNodeEnv = defaultMode;
+    const viteContextResolved = [inlineConfig, command, defaultMode, defaultNodeEnv, isPreview];
+    return viteContextResolved;
+}
+function normalizeViteRoot(root) {
+    // `path.resolve(viteConfigFromUserViteFile.configFile, root)` could be more intuitive than `path.resolve(process.cwd(), root)` but we replicate Vite's behavior (`vite.config.js` should follow Vite's API), see:
+    // https://github.com/vitejs/vite/blob/4f5845a3182fc950eb9cd76d7161698383113b18/packages/vite/src/node/config.ts#L1063
+    return toPosixPath(
+    // Equivalent to `path.resolve(process.cwd(), root)`
+    path.resolve(root));
+}
+const errMsg = `A Vite plugin is modifying Vite's setting ${pc.cyan('root')} which is forbidden`;
+async function assertViteRoot2(root, viteConfigFromUserResolved, viteContext) {
+    const viteContextResolved = resolveViteContext(viteConfigFromUserResolved, viteContext);
+    // We can eventually remove this resolveConfig() call (along with removing the whole assertViteRoot2() function which is redundant with the assertViteRoot() function) so that Vike doesn't make any resolveConfig() (except for pre-rendering and preview which is required). But let's keep it for now, just to see whether calling resolveConfig() can be problematic.
+    const viteConfigResolved = await resolveConfig(...viteContextResolved);
+    assertUsage(normalizeViteRoot(viteConfigResolved.root) === normalizeViteRoot(root), errMsg);
+    return { viteConfigResolved };
+}
+function assertViteRoot(root, config) {
+    if (globalObject.root)
+        assert(normalizeViteRoot(globalObject.root) === normalizeViteRoot(root));
+    assertUsage(normalizeViteRoot(root) === normalizeViteRoot(config.root), errMsg);
+}

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

@@ -5,8 +5,8 @@ import { parseJson5 } from '../vite/shared/getEnvVarObject.js';
 const commands = [
     { name: 'dev', desc: 'Start development server' },
     { name: 'build', desc: 'Build for production' },
-    { name: 'preview', desc: 'Start preview server using production build (only works for SSG apps)' },
-    { name: 'prerender', desc: 'Pre-render pages (only needed when prerender.disableAutoRun is true)' },
+    { name: 'preview', desc: 'Start preview server using production build' },
+    { name: 'prerender', desc: 'Pre-render pages (only needed when +prerender.disableAutoRun is true)' },
 ];
 function parseCli() {
     const command = getCommand();
@@ -51,7 +51,7 @@ function getCliOptions() {
     return cliOptions;
 }
 function showHelp() {
-    const TAB = ' '.repeat(3);
+    const TAB = ' '.repeat(2);
     const nameMaxLength = Math.max(...commands.map((c) => c.name.length));
     console.log([
         `vike@${PROJECT_VERSION}`,
@@ -60,13 +60,17 @@ function showHelp() {
         ...[...commands, { name: '-v', desc: "Print Vike's installed version" }].map((c) => `  ${pc.dim('$')} vike ${c.name.startsWith('-') ? pc.cyan(`${c.name}`) : pc.bold(`${c.name}`)}${' '.repeat(nameMaxLength - c.name.length)}${TAB}${pc.dim(`# ${c.desc}`)}`),
         '',
         'Common CLI options:',
-        [`vike dev ${pc.cyan('--host')}`, `vike dev ${pc.cyan('--port')} 80`, `vike build ${pc.cyan('--mode')} staging`]
+        [
+            `vike dev ${pc.cyan('--host')}          ${TAB}${pc.dim('# Make server available over LAN and public addresses')}`,
+            `vike dev ${pc.cyan('--port')} 80       ${TAB}${pc.dim('# Change the server port')}`,
+            `vike build ${pc.cyan('--mode')} staging${TAB}${pc.dim('# Set the mode to run in')}`,
+            `vike dev ${pc.cyan('--force')}         ${TAB}${pc.dim("# Disable Vite's cache")}`,
+        ]
             .map((o) => `  ${pc.dim('$')} ${o}`)
             .join('\n'),
         '',
-        `More Vike settings can be passed over the ${pc.cyan('VIKE_CONFIG')} environment variable or as ${pc.cyan('CLI options')}.`,
+        `More Vike settings can be passed over the ${pc.cyan('VIKE_CONFIG')} environment variable or as ${pc.cyan('CLI option')}.`,
         `More Vite settings can be passed over the ${pc.cyan('VITE_CONFIG')} environment variable.`,
-        ``,
         `See ${pc.underline('https://vike.dev/cli')} for more information.`,
     ].join('\n'));
     process.exit(1);

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

@@ -539,7 +539,7 @@ async function warnMissingPages(prerenderedPageContexts, globalContext, doNotPre
         .filter((pageId) => !isErrorPage(pageId, globalContext._pageConfigs))
         .forEach((pageId) => {
         const pageAt = isV1 ? pageId : `\`${pageId}.page.*\``;
-        assertWarning(partial, `Cannot pre-render page ${pageAt} because it has a non-static route, while there isn't any ${hookName}() hook returning an URL matching the page's route. You must use a ${hookName}() hook (https://vike.dev/${hookName}) for providing the list of URLs to be pre-rendered for that page. If you want to skip pre-rendering that page, you can remove this warning by setting +prerender to false at ${pageAt} (https://vike.dev/prerender#toggle) or by setting +prerender.partial to true (https://vike.dev/prerender#partial).`, { onlyOnce: true });
+        assertWarning(partial, `Cannot pre-render page ${pageAt} because it has a non-static route, while there isn't any ${hookName}() hook returning an URL matching the page's route. You must use a ${hookName}() hook (https://vike.dev/${hookName}) for providing the list of URLs to be pre-rendered for that page. If you want to skip pre-rendering that page, you can remove this warning by setting +prerender to false at ${pageAt} (https://vike.dev/pre-rendering#partial) or by setting +prerender.partial to true (https://vike.dev/prerender#partial).`, { onlyOnce: true });
     });
 }
 async function writeFiles({ pageContext, htmlString, pageContextSerialized }, viteConfig, onPagePrerender, prerenderContext, logLevel) {
@@ -690,6 +690,7 @@ function preparePrerenderContextForPublicUsage(prerenderContext) {
                 });
                 return prerenderContext.pageContexts;
             },
+            configurable: true,
         });
     }
     // Required because of https://vike.dev/i18n#pre-rendering

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

@@ -6,7 +6,7 @@ import { assert } from './utils.js';
 import { logErrorHint } from '../runtime/renderPage/logErrorHint.js';
 import { prepareViteApiCall } from '../api/prepareViteApiCall.js';
 import { isVikeCli } from '../cli/context.js';
-import { isViteCliCall } from '../vite/shared/isViteCliCall.js';
+import { isViteCli } from '../vite/shared/isViteCli.js';
 import { runPrerender } from './runPrerender.js';
 async function runPrerenderFromAPI(options = {}) {
     // - We purposely propagate the error to the user land, so that the error interrupts the user land. It's also, I guess, a nice-to-have that the user has control over the error.
@@ -16,8 +16,8 @@ async function runPrerenderFromAPI(options = {}) {
 }
 async function runPrerenderFromCLIPrerenderCommand() {
     try {
-        const { viteConfigFromUserEnhanced } = await prepareViteApiCall({}, 'prerender');
-        await runPrerender({ viteConfig: viteConfigFromUserEnhanced }, '$ vike prerender');
+        const { viteConfigFromUserResolved } = await prepareViteApiCall({}, 'prerender');
+        await runPrerender({ viteConfig: viteConfigFromUserResolved }, '$ vike prerender');
     }
     catch (err) {
         console.error(err);
@@ -38,7 +38,7 @@ async function runPrerenderFromAutoRun(viteConfig) {
         logErrorHint(err);
         process.exit(1);
     }
-    const forceExit = isVikeCli() || isViteCliCall();
+    const forceExit = isVikeCli() || isViteCli();
     return { forceExit };
 }
 function runPrerender_forceExit() {

package/dist/esm/node/runtime/globalContext.d.ts

@@ -2,6 +2,7 @@ export { getGlobalContext };
 export { getGlobalContextSync };
 export { getGlobalContextAsync };
 export { getGlobalContextServerInternal };
+export { getGlobalContextServerInternalOptional };
 export { getViteDevServer };
 export { getViteConfig };
 export { initGlobalContext_renderPage };
@@ -246,6 +247,97 @@ declare function getGlobalContextServerInternal(): Promise<{
         prerenderContext: PrerenderContext | undefined;
     });
 }>;
+declare function getGlobalContextServerInternalOptional(): (Record<string, unknown> & (({
+    _globalConfigPublic: {
+        pages: {
+            [k: string]: {
+                config: import("../../types/index.js").ConfigResolved;
+                _source: import("../../shared/page-configs/resolveVikeConfigPublic.js").Source;
+                _sources: import("../../shared/page-configs/resolveVikeConfigPublic.js").Sources;
+                _from: import("../../shared/page-configs/resolveVikeConfigPublic.js").From;
+            } & ({
+                route: import("../../types/Config.js").Route;
+                isErrorPage?: undefined;
+            } | {
+                route?: undefined;
+                isErrorPage: true;
+            });
+        };
+        config: import("../../types/index.js").ConfigResolved;
+        _source: import("../../shared/page-configs/resolveVikeConfigPublic.js").Source;
+        _sources: import("../../shared/page-configs/resolveVikeConfigPublic.js").Sources;
+        _from: import("../../shared/page-configs/resolveVikeConfigPublic.js").From;
+    };
+    pages: {
+        [k: string]: {
+            config: import("../../types/index.js").ConfigResolved;
+            _source: import("../../shared/page-configs/resolveVikeConfigPublic.js").Source;
+            _sources: import("../../shared/page-configs/resolveVikeConfigPublic.js").Sources;
+            _from: import("../../shared/page-configs/resolveVikeConfigPublic.js").From;
+        } & ({
+            route: import("../../types/Config.js").Route;
+            isErrorPage?: undefined;
+        } | {
+            route?: undefined;
+            isErrorPage: true;
+        });
+    };
+    config: import("../../types/index.js").ConfigResolved;
+    _source: import("../../shared/page-configs/resolveVikeConfigPublic.js").Source;
+    _sources: import("../../shared/page-configs/resolveVikeConfigPublic.js").Sources;
+    _from: import("../../shared/page-configs/resolveVikeConfigPublic.js").From;
+    isGlobalContext: true;
+    _isOriginalObject: true;
+    _virtualFileExportsGlobalEntry: unknown;
+    _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
+    _pageConfigs: import("../../types/PageConfig.js").PageConfigRuntime[];
+    _pageConfigGlobal: import("../../types/PageConfig.js").PageConfigGlobalRuntime;
+    _allPageIds: string[];
+} & (({
+    _isProduction: false;
+    _isPrerendering: false;
+    assetsManifest: null;
+    _viteDevServer: ViteDevServer | undefined;
+    viteConfig: ResolvedConfig | undefined;
+    isClientSide: false;
+    _pageRoutes: PageRoutes;
+    _onBeforeRouteHook: Hook | null;
+} | {
+    _isPrerendering: true;
+    viteConfig: ResolvedConfig;
+    _isProduction: true;
+    assetsManifest: ViteManifest;
+    _viteDevServer: null;
+    _usesClientRouter: boolean;
+    isClientSide: false;
+    _pageRoutes: PageRoutes;
+    _onBeforeRouteHook: Hook | null;
+} | {
+    _isPrerendering: false;
+    viteConfig: null;
+    _isProduction: true;
+    assetsManifest: ViteManifest;
+    _viteDevServer: null;
+    _usesClientRouter: boolean;
+    isClientSide: false;
+    _pageRoutes: PageRoutes;
+    _onBeforeRouteHook: Hook | null;
+}) & {
+    baseServer: string;
+    baseAssets: string;
+    viteConfigRuntime: {
+        root: string;
+        build: {
+            outDir: string;
+        };
+        _baseViteOriginal: string;
+        vitePluginServerEntry: {
+            inject: boolean | undefined;
+        };
+    };
+})) & {
+    prerenderContext: PrerenderContext | undefined;
+})) | null;
 /**
  * Get runtime information about your app.
  *

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

@@ -4,6 +4,7 @@ export { getGlobalContextSync };
 export { getGlobalContextAsync };
 // Internal use
 export { getGlobalContextServerInternal };
+export { getGlobalContextServerInternalOptional };
 export { getViteDevServer };
 export { getViteConfig };
 export { initGlobalContext_renderPage };
@@ -58,6 +59,12 @@ async function getGlobalContextServerInternal() {
     assertIsDefined(globalContext);
     return { globalContext };
 }
+function getGlobalContextServerInternalOptional() {
+    const { globalContext } = globalObjectTyped;
+    if (!globalContext)
+        return null;
+    return globalContext;
+}
 function assertIsDefined(globalContext) {
     if (!globalContext) {
         debug('globalContext', globalContext);
@@ -556,7 +563,8 @@ function isProdOptional() {
     const yes5 = globalObject.isProductionAccordingToUser === true;
     // vite-plugin-vercel
     const yes6 = globalObject.isProductionAccordingToPhotonVercel === true;
-    const yes = yes1 || yes2 || yes3 || yes4 || yes5 || yes6;
+    const yes7 = globalThis.__VIKE__IS_DEV === false;
+    const yes = yes1 || yes2 || yes3 || yes4 || yes5 || yes6 || yes7;
     const no1 = !!globalObject.viteDevServer;
     // Vike CLI & Vike API
     const no2 = vikeApiOperation === 'dev';
@@ -566,8 +574,9 @@ function isProdOptional() {
     const no4 = globalObject.isProductionAccordingToUser === false;
     // @cloudflare/vite-plugin
     const no5 = isNonRunnableDev();
-    const no = no1 || no2 || no3 || no4 || no5;
-    const debug = { yes1, yes2, yes3, yes4, yes5, yes6, no1, no2, no3, no4, no5 };
+    const no6 = globalThis.__VIKE__IS_DEV === true;
+    const no = no1 || no2 || no3 || no4 || no5 || no6;
+    const debug = { yes1, yes2, yes3, yes4, yes5, yes6, yes7, no1, no2, no3, no4, no5, no6 };
     assert(typeof yes === 'boolean', debug);
     assert(typeof no === 'boolean', debug);
     if (yes) {

package/dist/esm/node/runtime/logErrorServer.d.ts

@@ -0,0 +1,2 @@
+export { logErrorServer };
+declare function logErrorServer(err: unknown): void;

package/dist/esm/node/runtime/logErrorServer.js

@@ -0,0 +1,18 @@
+export { logErrorServer };
+import pc from '@brillout/picocolors';
+import { isCallable, isObject } from './utils.js';
+import { execHookOnError } from './renderPage/execHookOnError.js';
+function logErrorServer(err) {
+    execHookOnError(err);
+    // Set by react-streaming
+    // - https://github.com/brillout/react-streaming/blob/0fb5510d0a5a614f577668a519bccd62de40aed8/src/server/renderToStream/common.ts#L59-L62
+    // - https://gist.github.com/brillout/066293a687ab7cf695e62ad867bc6a9c
+    // - It doesn't seem to be needed? (The error Vike receives is already enhanced.) Should we remove this?
+    if (isObject(err) && isCallable(err.getEnhancedError)) {
+        err = err.getEnhancedError(err);
+    }
+    // We ensure we print a string; Cloudflare Workers doesn't seem to properly stringify `Error` objects.
+    // - TO-DO/eventually: is that still true? Let's eventually remove it and see if it crashes Cloudflare.
+    const errStr = isObject(err) && 'stack' in err ? String(err.stack) : String(err);
+    console.error(pc.red(errStr));
+}

package/dist/esm/node/runtime/renderPage/execHookOnError.d.ts

@@ -0,0 +1,2 @@
+export { execHookOnError };
+declare function execHookOnError(err: unknown): void;

package/dist/esm/node/runtime/renderPage/execHookOnError.js

@@ -0,0 +1,26 @@
+export { execHookOnError };
+import { isObject, getGlobalObject } from '../utils.js';
+import { getGlobalContextServerInternalOptional } from '../globalContext.js';
+import { getHookFromPageConfigGlobalCumulative } from '../../../shared/hooks/getHook.js';
+const globalObject = getGlobalObject('renderPage/execHookOnError.ts', {
+    seen: new WeakSet(),
+});
+function execHookOnError(err) {
+    if (isObject(err)) {
+        if (globalObject.seen.has(err))
+            return;
+        globalObject.seen.add(err);
+    }
+    const globalContext = getGlobalContextServerInternalOptional();
+    if (!globalContext)
+        return;
+    const hooks = getHookFromPageConfigGlobalCumulative(globalContext._pageConfigGlobal, 'onError');
+    for (const hook of hooks) {
+        try {
+            hook.hookFn(err);
+        }
+        catch (hookErr) {
+            console.error(hookErr);
+        }
+    }
+}

package/dist/esm/node/runtime/renderPage/execHookServer.d.ts

@@ -5,7 +5,7 @@ import type { PageContextConfig } from '../../../shared/getPageFiles.js';
 import type { HookName } from '../../../types/Config.js';
 type PageContextExecHookServer = PageContextConfig & PageContextForPublicUsageServer;
 declare function execHookServer(hookName: HookName, pageContext: PageContextExecHookServer): Promise<(import("../../../shared/hooks/getHook.js").HookLoc & {
-    hookFn: (arg: import("../../../shared/preparePageContextForPublicUsage.js").PageContextPrepareMinimum | import("../../../shared/prepareGlobalContextForPublicUsage.js").GlobalContextPrepareMinimum) => unknown;
+    hookFn: (arg: import("../../../shared/preparePageContextForPublicUsage.js").PageContextPrepareMinimum) => unknown;
     hookTimeout: import("../../../shared/hooks/getHook.js").HookTimeout;
 } & {
     hookReturn: unknown;

package/dist/esm/node/runtime/renderPage/loggerProd.js

@@ -4,18 +4,16 @@ export { logErrorProd };
 export { onRuntimeError };
 import { isAbortError } from '../../../shared/route/abort.js';
 import { setAlreadyLogged } from './isNewError.js';
-import { isObject, warnIfErrorIsNotObject } from '../utils.js';
-import pc from '@brillout/picocolors';
+import { warnIfErrorIsNotObject } from '../utils.js';
 import { logErrorHint } from './logErrorHint.js';
+import { logErrorServer } from '../logErrorServer.js';
 function logErrorProd(err, _httpRequestId) {
     warnIfErrorIsNotObject(err);
     setAlreadyLogged(err);
     if (isAbortError(err)) {
         return;
     }
-    // We ensure we print a string; Cloudflare Workers doesn't seem to properly stringify `Error` objects.
-    const errStr = isObject(err) && 'stack' in err ? String(err.stack) : String(err);
-    console.error(pc.red(errStr));
+    logErrorServer(err);
     // Needs to be called after logging the error.
     onRuntimeError(err);
 }

package/dist/esm/node/runtime/renderPage.js

@@ -64,11 +64,12 @@ async function renderPagePrepare(pageContextInit, httpRequestId) {
         await initGlobalContext_renderPage();
     }
     catch (err) {
-        // Errors are expected since assertUsage() is used in initGlobalContext_renderPage() such as:
-        // ```bash
-        // Re-build your app (you're using 1.2.3 but your app was built with 1.2.2)
-        // ```
-        // initGlobalContext_renderPage() doesn't call any user hook => err isn't thrown from user code.
+        // Errors are expected:
+        // - assertUsage() such as:
+        //   ```bash
+        //   Re-build your app (you're using 1.2.3 but your app was built with 1.2.2)
+        //   ```
+        // - initGlobalContext_renderPage() depends on +onCreateGlobalContext hooks
         assert(!isAbortError(err));
         logRuntimeError(err, httpRequestId);
         const pageContextWithError = getPageContextHttpResponseErrorWithoutGlobalContext(err, pageContextInit);
@@ -245,7 +246,7 @@ function logHttpResponse(urlOriginalPretty, httpRequestId, pageContextReturn) {
             msg = `HTTP ${type} ${prettyUrl(urlOriginalPretty)} ${color(statusCode ?? 'ERR')}`;
         }
     }
-    logRuntimeInfo?.(msg, httpRequestId, isNominal ? 'info' : 'error');
+    logRuntimeInfo?.(msg, httpRequestId, isNominal ? 'info' : 'error-note');
 }
 function prettyUrl(url) {
     try {
@@ -485,7 +486,7 @@ function getPageContextSkipRequest(pageContextInit) {
     return pageContext;
 }
 function getPageContextInvalidVikeConfig(err, pageContextInit, httpRequestId) {
-    logRuntimeInfo?.(pc.bold(pc.red('Error loading Vike config — see error above')), httpRequestId, 'error');
+    logRuntimeInfo?.(pc.bold(pc.red('Error loading Vike config — see error above')), httpRequestId, 'error-note');
     const pageContextWithError = getPageContextHttpResponseErrorWithoutGlobalContext(err, pageContextInit);
     return pageContextWithError;
 }

package/dist/esm/node/runtime-dev/createDevMiddleware.js

@@ -18,8 +18,8 @@ async function createDevMiddleware(options = {}) {
             },
         },
     };
-    const { viteConfigFromUserEnhanced } = await prepareViteApiCall(optionsMod, 'dev');
-    const server = await createServer(viteConfigFromUserEnhanced);
+    const { viteConfigFromUserResolved } = await prepareViteApiCall(optionsMod, 'dev');
+    const server = await createServer(viteConfigFromUserResolved);
     const devMiddleware = server.middlewares;
     return { devMiddleware, viteServer: server, viteConfig: server.config };
 }

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

@@ -8,7 +8,7 @@ export type { VikeVitePluginOptions };
 type PluginInterop = Record<string, unknown> & {
     name: string;
 };
-declare function plugin(vikeVitePluginOptions?: VikeVitePluginOptions): PluginInterop[];
+declare function plugin(vikeVitePluginOptions?: VikeVitePluginOptions): Promise<PluginInterop[]>;
 /** @deprecated Define Vike settings in +config.js instead of vite.config.js */
 type VikeVitePluginOptions = {
     /** @deprecated Define Vike settings in +config.js instead of vite.config.js */