vike 0.4.240 → 0.4.241

package/dist/esm/client/runtime-client-routing/getPageContextFromHooks.d.ts

@@ -445,7 +445,7 @@ declare function getPageContextFromClientHooks(pageContext: {
 }>;
 type PageContextExecHookClient = PageContextConfig & PageContextForPublicUsageClient;
 declare function execHookClient(hookName: HookName, pageContext: PageContextExecHookClient): 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/client/runtime-client-routing/getPageContextFromHooks.js

@@ -168,7 +168,7 @@ function hasServerOnlyHook(pageContext) {
     if (isOldDesign(pageContext))
         return false;
     const pageConfig = getPageConfig(pageContext.pageId, pageContext._globalContext._pageConfigs);
-    const val = getConfigValueRuntime(pageConfig, `serverOnlyHooks`)?.value;
+    const val = getConfigValueRuntime(pageConfig, `hasServerOnlyHook`)?.value;
     assert(val === true || val === false);
     return val;
 }

package/dist/esm/client/runtime-client-routing/logErrorClient.d.ts

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

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

@@ -0,0 +1,11 @@
+export { logErrorClient };
+import { isObject } from './utils.js';
+function logErrorClient(err) {
+    if (isObject(err) &&
+        // Set by vike-react
+        // https://github.com/vikejs/vike-react/blob/195a208c6b77e7f34496e1f637278a36c60fbe07/packages/vike-react/src/integration/onRenderClient.tsx#L109
+        err.isAlreadyLogged) {
+        return;
+    }
+    console.error(err);
+}

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

@@ -3,7 +3,7 @@ export { getRenderCount };
 export { disableClientRouting };
 export { firstRenderStartPromise };
 export { getPageContextClient };
-import { assert, isSameErrorMessage, objectAssign, redirectHard, getGlobalObject, hasProp, updateType, genPromise, isCallable, catchInfiniteLoop, } from './utils.js';
+import { assert, objectAssign, redirectHard, getGlobalObject, hasProp, updateType, genPromise, isCallable, catchInfiniteLoop, } from './utils.js';
 import { getPageContextFromClientHooks, getPageContextFromServerHooks, getPageContextFromHooks_isHydration, getPageContextFromHooks_serialized, setPageContextInitIsPassedToClient, } from './getPageContextFromHooks.js';
 import { createPageContextClientSide } from './createPageContextClientSide.js';
 import { addLinkPrefetchHandlers, addLinkPrefetchHandlers_unwatch, addLinkPrefetchHandlers_watch, getPageContextPrefetched, populatePageContextPrefetchCache, } from './prefetch.js';
@@ -24,6 +24,7 @@ import { execHookDirect, execHook } from '../../shared/hooks/execHook.js';
 import { preparePageContextForPublicUsageClient, } from './preparePageContextForPublicUsageClient.js';
 import { getHookFromPageContextNew } from '../../shared/hooks/getHook.js';
 import { preparePageContextForPublicUsageClientMinimal } from '../shared/preparePageContextForPublicUsageClientShared.js';
+import { logErrorClient } from './logErrorClient.js';
 const globalObject = getGlobalObject('runtime-client-routing/renderPageClientSide.ts', (() => {
     const { promise: firstRenderStartPromise, resolve: firstRenderStartPromiseResolve } = genPromise();
     return {
@@ -60,7 +61,7 @@ async function renderPageClientSide(renderArgs) {
     return;
     async function renderPageNominal() {
         const onError = async (err) => {
-            await renderPageOnError({ err });
+            await handleError({ err });
         };
         const pageContext = await getPageContextBegin(false, pageContextBeginArgs);
         if (isRenderOutdated())
@@ -229,96 +230,68 @@ async function renderPageClientSide(renderArgs) {
             await renderPageView(pageContext);
         }
     }
-    // When the normal page threw an error
+    // When the normal page threw an error:
     // - Can be a URL rewrite upon `throw render('/some-url')`
     // - Can be rendering the error page
     // - Can be rendering Vike's generic error page (if no error page is defined, or if the error page throws an error)
-    async function renderPageOnError(args) {
-        const onError = (err) => {
-            if (!isSameErrorMessage(err, args.err)) {
-                /* When we can't render the error page, we prefer showing a blank page over letting the server-side try because otherwise:
-                   - We risk running into an infinite loop of reloads which would overload the server.
-                   - An infinite reloading page is a even worse UX than a blank page.
-                redirectHard(urlOriginal)
-                */
-                console.error(err);
-            }
-        };
-        if ('err' in args) {
-            const { err } = args;
-            assert(err);
-            if (!isAbortError(err)) {
-                // We don't swallow 404 errors:
-                //  - On the server-side, Vike swallows / doesn't show any 404 error log because it's expected that a user may go to some random non-existent URL. (We don't want to flood the app's error tracking with 404 logs.)
-                //  - On the client-side, if the user navigates to a 404 then it means that the UI has a broken link. (It isn't expected that users can go to some random URL using the client-side router, as it would require, for example, the user to manually change the URL of a link by manually manipulating the DOM which highly unlikely.)
-                console.error(err);
-            }
-            else {
-                // We swallow throw redirect()/render() called by client-side hooks onBeforeRender()/data()/guard()
-                // We handle the abort error down below.
-            }
+    async function handleError(args) {
+        const { err } = args;
+        assert(err);
+        // Logging
+        if (!isAbortError(err)) {
+            // We don't swallow 404 errors:
+            //  - On the server-side, Vike swallows / doesn't show any 404 error log because it's expected that a user may go to some random non-existent URL. (We don't want to flood the app's error tracking with 404 logs.)
+            //  - On the client-side, if the user navigates to a 404 then it means that the UI has a broken link. (It isn't expected that users can go to some random URL using the client-side router, as it would require, for example, the user to manually change the URL of a link by manually manipulating the DOM which highly unlikely.)
+            logErrorClient(err);
+        }
+        else {
+            // We swallow throw redirect()/render() called by client-side hooks onBeforeRender()/data()/guard()
+            // We handle the abort error down below.
         }
+        // pageContext
         const pageContext = await getPageContextBegin(true, pageContextBeginArgs);
         if (isRenderOutdated())
             return;
-        objectAssign(pageContext, { routeParams: {} });
-        if (args.pageContextError)
-            objectAssign(pageContext, args.pageContextError);
-        if ('err' in args) {
-            const { err } = args;
-            assert(!('errorWhileRendering' in pageContext));
-            objectAssign(pageContext, { errorWhileRendering: err });
-            if (isAbortError(err)) {
-                const errAbort = err;
-                logAbortErrorHandled(err, !import.meta.env.DEV, pageContext);
-                const pageContextAbort = errAbort._pageContextAbort;
-                // throw render('/some-url')
-                if (pageContextAbort._urlRewrite) {
-                    await renderPageClientSide({
-                        ...renderArgs,
-                        scrollTarget: undefined,
-                        pageContextsFromRewrite: [...pageContextsFromRewrite, pageContextAbort],
-                    });
-                    return;
-                }
-                // throw redirect('/some-url')
-                if (pageContextAbort._urlRedirect) {
-                    const urlRedirect = pageContextAbort._urlRedirect.url;
-                    if (!urlRedirect.startsWith('/')) {
-                        // External redirection
-                        redirectHard(urlRedirect);
-                        return;
-                    }
-                    else {
-                        await renderPageClientSide({
-                            ...renderArgs,
-                            scrollTarget: undefined,
-                            urlOriginal: urlRedirect,
-                            overwriteLastHistoryEntry: false,
-                            isBackwardNavigation: false,
-                            redirectCount: redirectCount + 1,
-                        });
-                    }
-                    return;
-                }
-                // throw render(statusCode)
-                assert(pageContextAbort.abortStatusCode);
-                assert(!('urlOriginal' in pageContextAbort));
-                objectAssign(pageContext, pageContextAbort);
-                if (pageContextAbort.abortStatusCode === 404) {
-                    objectAssign(pageContext, { is404: true });
-                }
-            }
-            else {
-                objectAssign(pageContext, { is404: false });
-            }
+        objectAssign(pageContext, {
+            errorWhileRendering: err,
+        });
+        // throw redirect()/render()
+        let pageContextAbort;
+        if (isAbortError(err)) {
+            const res = await handleAbortError(err, pageContext);
+            if (res.skip)
+                return;
+            pageContextAbort = res.pageContextAbort;
         }
+        // Render error page
+        await renderErrorPage(pageContext, args, pageContextAbort);
+    }
+    async function renderErrorPage(pageContext, args, pageContextAbort) {
+        const onError = (err) => {
+            /* When we can't render the error page, we prefer showing a blank page over letting the server-side try because otherwise:
+               - We risk running into an infinite loop of reloads which would overload the server.
+               - An infinite reloading page is a even worse UX than a blank page.
+            redirectHard(urlOriginal)
+            */
+            logErrorClient(err);
+        };
         const errorPageId = getErrorPageId(pageContext._pageFilesAll, pageContext._globalContext._pageConfigs);
         if (!errorPageId)
             throw new Error('No error page defined.');
         objectAssign(pageContext, {
             pageId: errorPageId,
+            routeParams: {},
         });
+        // throw render(statusCode)
+        if (pageContextAbort) {
+            assert(pageContextAbort.abortStatusCode);
+            assert(!('urlOriginal' in pageContextAbort));
+            objectAssign(pageContext, pageContextAbort);
+            objectAssign(pageContext, { is404: pageContextAbort.abortStatusCode === 404 });
+        }
+        else {
+            objectAssign(pageContext, { is404: false });
+        }
         const isClientRoutable = await isClientSideRoutable(pageContext.pageId, pageContext);
         if (isRenderOutdated())
             return;
@@ -326,6 +299,9 @@ async function renderPageClientSide(renderArgs) {
             redirectHard(urlOriginal);
             return;
         }
+        if (import.meta.env.DEV || globalThis.__VIKE__IS_DEBUG) {
+            assertInfo(false, `Rendering error page ${errorPageId}`, { onlyOnce: false });
+        }
         const res = await loadPageConfigsLazyClientSideAndExecHook(pageContext, isFirstRender, isRenderOutdated);
         /* Already called inside loadPageConfigsLazyClientSideAndExecHook()
         if (isRenderOutdated()) return
@@ -367,15 +343,49 @@ async function renderPageClientSide(renderArgs) {
         updateType(pageContext, pageContextFromClientHooks);
         await renderPageView(pageContext, args);
     }
+    async function handleAbortError(err, pageContext) {
+        const errAbort = err;
+        logAbortErrorHandled(err, !import.meta.env.DEV, pageContext);
+        const pageContextAbort = errAbort._pageContextAbort;
+        // throw render('/some-url')
+        if (pageContextAbort._urlRewrite) {
+            await renderPageClientSide({
+                ...renderArgs,
+                scrollTarget: undefined,
+                pageContextsFromRewrite: [...pageContextsFromRewrite, pageContextAbort],
+            });
+            return { skip: true };
+        }
+        // throw redirect('/some-url')
+        if (pageContextAbort._urlRedirect) {
+            const urlRedirect = pageContextAbort._urlRedirect.url;
+            if (!urlRedirect.startsWith('/')) {
+                // External redirection
+                redirectHard(urlRedirect);
+                return { skip: true };
+            }
+            else {
+                await renderPageClientSide({
+                    ...renderArgs,
+                    scrollTarget: undefined,
+                    urlOriginal: urlRedirect,
+                    overwriteLastHistoryEntry: false,
+                    isBackwardNavigation: false,
+                    redirectCount: redirectCount + 1,
+                });
+            }
+            return { skip: true };
+        }
+        // throw render(statusCode)
+        return { pageContextAbort };
+    }
     async function renderPageView(pageContext, isErrorPage) {
         const onError = async (err) => {
             if (!isErrorPage) {
-                await renderPageOnError({ err });
+                await handleError({ err });
             }
             else {
-                if (!isSameErrorMessage(err, isErrorPage.err)) {
-                    console.error(err);
-                }
+                logErrorClient(err);
             }
         };
         // We use globalObject.onRenderClientPreviousPromise in order to ensure that there is never two concurrent onRenderClient() calls
@@ -395,6 +405,7 @@ async function renderPageClientSide(renderArgs) {
                 await execHookOnRenderClient(pageContext, preparePageContextForPublicUsageClient);
             }
             catch (err) {
+                assert(err);
                 onRenderClientError = err;
             }
             globalObject.onRenderClientPreviousPromise = undefined;
@@ -505,10 +516,10 @@ function changeUrl(url, overwriteLastHistoryEntry) {
     pushHistoryState(url, overwriteLastHistoryEntry);
 }
 function disableClientRouting(err, log) {
-    assert(isErrorFetchingStaticAssets(err));
     globalObject.clientRoutingIsDisabled = true;
+    assert(isErrorFetchingStaticAssets(err));
     if (log) {
-        // We don't use console.error() to avoid flooding error trackers such as Sentry
+        // We purposely don't use console.error() to avoid flooding error trackers such as Sentry
         console.log(err);
     }
     assertInfo(false, [

package/dist/esm/client/runtime-client-routing/utils.d.ts

@@ -7,7 +7,6 @@ export * from '../../utils/isCallable.js';
 export * from '../../utils/isObject.js';
 export * from '../../utils/isPlainObject.js';
 export * from '../../utils/isReact.js';
-export * from '../../utils/isSameErrorMessage.js';
 export * from '../../utils/objectAssign.js';
 export * from '../../utils/parseUrl.js';
 export * from '../../utils/PromiseType.js';

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

@@ -11,7 +11,6 @@ export * from '../../utils/isCallable.js';
 export * from '../../utils/isObject.js';
 export * from '../../utils/isPlainObject.js';
 export * from '../../utils/isReact.js';
-export * from '../../utils/isSameErrorMessage.js';
 export * from '../../utils/objectAssign.js';
 export * from '../../utils/parseUrl.js';
 export * from '../../utils/PromiseType.js';

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/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,11 @@
+export { logErrorServer };
+import pc from '@brillout/picocolors';
+import { isObject } from './utils.js';
+import { execHookOnError } from './renderPage/execHookOnError.js';
+function logErrorServer(err) {
+    execHookOnError(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;
 }