vike 0.4.240 → 0.4.241

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

@@ -6,6 +6,7 @@ import { assert, stripAnsi, hasProp, assertIsNotProductionRuntime, PROJECT_VERSI
 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);
@@ -39,10 +40,15 @@ function logDirectly(thing, logType) {
         console.warn(thing);
         return;
     }
-    if (logType === 'error') {
+    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);
@@ -63,7 +69,7 @@ function applyViteSourceMapToStackTrace(thing) {
 }
 function prependTags(msg, projectTag, category, logType) {
     const color = (s) => {
-        if (logType === 'error' && !hasRed(msg))
+        if (logType === 'error-thrown' && !hasRed(msg))
             return pc.bold(pc.red(s));
         if (logType === 'error-recover' && !hasGreen(msg))
             return pc.bold(pc.green(s));

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

@@ -10,7 +10,7 @@ export type { LogError };
 export type { LogErrorArgs };
 export type { LogType };
 export type { LogCategory };
-type LogType = 'info' | 'warn' | 'error' | 'error-recover';
+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>;

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

@@ -89,7 +89,7 @@ function logErr(err, httpRequestId = null, errorComesFromVite) {
             assert(viteConfig);
             const prettyErr = getPrettyErrorWithCodeSnippet(err, viteConfig.root);
             assert(stripAnsi(prettyErr).startsWith('Failed to transpile'));
-            logWithViteTag(prettyErr, 'error', category);
+            logWithViteTag(prettyErr, 'error-thrown', category);
             logErrorDebugNote();
             return;
         }
@@ -103,12 +103,12 @@ function logErr(err, httpRequestId = null, errorComesFromVite) {
     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', category);
+        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');
+    logDirectly(err, 'error-thrown');
     // Needs to be called after logging the error.
     onRuntimeError(err);
 }
@@ -119,8 +119,8 @@ function logConfigError(err) {
         const errIntroMsg = getConfigExecutionErrorIntroMsg(err);
         if (errIntroMsg) {
             assert(stripAnsi(errIntroMsg).startsWith('Failed to execute'));
-            logWithVikeTag(errIntroMsg, 'error', category);
-            logDirectly(err, 'error');
+            logWithVikeTag(errIntroMsg, 'error-note', category);
+            logDirectly(err, 'error-thrown');
             return;
         }
     }
@@ -129,10 +129,10 @@ function logConfigError(err) {
         if (errMsgFormatted) {
             assert(stripAnsi(errMsgFormatted).startsWith('Failed to transpile'));
             if (!isErrorDebug()) {
-                logWithVikeTag(errMsgFormatted, 'error', category);
+                logWithVikeTag(errMsgFormatted, 'error-thrown', category);
             }
             else {
-                logDirectly(err, 'error');
+                logDirectly(err, 'error-thrown');
             }
             return;
         }
@@ -144,11 +144,11 @@ function logConfigError(err) {
     }
     if (category)
         logFallbackErrIntro(category, false);
-    logDirectly(err, 'error');
+    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', category);
+    logWithVikeTag(pc.bold(pc.red(`[Error] ${msg}:`)), 'error-note', category);
 }
 function getConfigCategory() {
     const category = getCategory() ?? 'config';
@@ -159,7 +159,7 @@ function handleAssertMsg(err, category) {
     if (!res)
         return false;
     const { assertMsg, showVikeVersion } = res;
-    logWithVikeTag(assertMsg, 'error', category, showVikeVersion);
+    logWithVikeTag(assertMsg, 'error-thrown', category, showVikeVersion);
     return true;
 }
 function assertLogger(thing, logType) {
@@ -189,7 +189,7 @@ function logErrorDebugNote() {
         store.errorDebugNoteAlreadyShown = true;
     }
     const msg = pc.dim(formatHintLog("Error isn't helpful? See https://vike.dev/debug#verbose-errors"));
-    logDirectly(msg, 'error');
+    logDirectly(msg, 'error-note');
 }
 function getCategory(httpRequestId = null) {
     const store = getHttpRequestAsyncStore();

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

@@ -9,8 +9,8 @@ function improveViteLogs(config) {
     intercept('warn', config);
     intercept('error', config);
 }
-function intercept(logType, config) {
-    config.logger[logType] = (msg, options = {}) => {
+function intercept(loggerType, config) {
+    config.logger[loggerType] = (msg, options = {}) => {
         assert(!isErrorDebug());
         if (removeSuperfluousViteLog(msg))
             return;
@@ -38,6 +38,8 @@ function intercept(logType, config) {
         }
         // Vite's default logger preprends the "[vite]" tag if and only if options.timestamp is true
         const prependViteTag = options.timestamp || !!store?.httpRequestId;
+        // If it's an actual error => options.error is set => it's handled with logViteError() above
+        const logType = loggerType === 'error' ? 'error-note' : loggerType;
         logViteAny(msg, logType, store?.httpRequestId ?? null, prependViteTag);
     };
 }

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

@@ -27,6 +27,11 @@ const configDefinitionsBuiltIn = {
         global: true,
         cumulative: true,
     },
+    onError: {
+        env: { server: true },
+        global: true,
+        cumulative: true,
+    },
     onBeforeRender: {
         env: { server: true },
     },
@@ -96,11 +101,11 @@ const configDefinitionsBuiltIn = {
     meta: {
         env: { config: true },
     },
-    serverOnlyHooks: {
+    hasServerOnlyHook: {
         env: { client: true },
         eager: true,
         _computed: (pageConfig) => {
-            const sources = ['data', 'onBeforeRender', 'onCreatePageContext']
+            const sources = ['data', 'onBeforeRender', 'onCreatePageContext', 'guard']
                 .map((hookName) => getConfigValueSourcesRelevant(hookName, {
                 isForClientSide: false,
                 // TO-DO/eventually/remove-server-router: let's eventually remove support for Server Routing
@@ -171,6 +176,10 @@ const configDefinitionsBuiltIn = {
         env: { config: true },
         global: true,
     },
+    force: {
+        env: { config: true },
+        global: true,
+    },
     csp: {
         env: { server: true },
     },
@@ -207,6 +216,7 @@ const configDefinitionsBuiltIn = {
         env: { config: true },
         global: true,
     },
+    // This is deprecated (since Summer 2025). But don't remove this (yet) — otherwise it will break older Vike extensions that still use it.
     vite6BuilderApp: {
         env: { config: true },
         global: true,

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

@@ -382,12 +382,7 @@ function triggerPrepareStackTrace(err) {
 }
 function getErrIntroMsg(operation, filePath) {
     const { filePathToShowToUserResolved } = filePath;
-    const msg = [
-        // prettier ignore
-        pc.red(`Failed to ${operation}`),
-        pc.bold(pc.red(filePathToShowToUserResolved)),
-        pc.red(`because:`),
-    ].join(' ');
+    const msg = `${pc.red(`Failed to ${operation}`)} ${pc.bold(pc.red(filePathToShowToUserResolved))} ${pc.red(`because:`)}`;
     return msg;
 }
 function cleanEsbuildErrors(errors) {

package/dist/esm/shared/createGlobalContextShared.d.ts

@@ -5,13 +5,14 @@ export type { GlobalContextBasePublic };
 export type GlobalContextInternal = GlobalContextServerInternal | GlobalContextClientInternal;
 import type { PageFile } from './getPageFiles.js';
 import type { PageConfigRuntime } from '../types/PageConfig.js';
+import { type GlobalContextPrepareMinimum } from './prepareGlobalContextForPublicUsage.js';
 import type { GlobalContextServerInternal } from '../node/runtime/globalContext.js';
 import type { GlobalContextClientInternal } from '../client/runtime-client-routing/getGlobalContextClientInternal.js';
 import { type Hook } from './hooks/getHook.js';
 declare const getGlobalContextSyncErrMsg = "The global context isn't set yet, call getGlobalContextSync() later or use getGlobalContext() instead.";
 declare function createGlobalContextShared<GlobalContextAdded extends {}, GlobalContextAddedAsync extends {}>(virtualFileExportsGlobalEntry: unknown, globalObject: {
     globalContext?: {};
-    onCreateGlobalContextHooks?: Hook[];
+    onCreateGlobalContextHooks?: Hook<GlobalContextPrepareMinimum>[];
     previousCreateGlobalContextPromise?: Promise<void>;
 }, addGlobalContext?: (globalContext: GlobalContextBase) => GlobalContextAdded, addGlobalContextTmp?: (globalContext: GlobalContextBase) => Promise<GlobalContextAdded>, addGlobalContextAsync?: (globalContext: GlobalContextBase) => Promise<GlobalContextAddedAsync>): Promise<{
     _globalConfigPublic: {

package/dist/esm/shared/createGlobalContextShared.js

@@ -4,7 +4,7 @@ import { assert, changeEnumerable, genPromise, objectAssign, objectReplace, uniq
 import { parseVirtualFileExportsGlobalEntry } from './getPageFiles/parseVirtualFileExportsGlobalEntry.js';
 import { resolveGlobalContextConfig } from './page-configs/resolveVikeConfigPublic.js';
 import { execHookGlobal } from './hooks/execHook.js';
-import { prepareGlobalContextForPublicUsage } from './prepareGlobalContextForPublicUsage.js';
+import { prepareGlobalContextForPublicUsage, } from './prepareGlobalContextForPublicUsage.js';
 import { getHookFromPageConfigGlobalCumulative } from './hooks/getHook.js';
 const getGlobalContextSyncErrMsg = "The global context isn't set yet, call getGlobalContextSync() later or use getGlobalContext() instead.";
 // TO-DO/eventually use flat globalContext — like flat pageContext

package/dist/esm/shared/hooks/execHook.d.ts

@@ -24,7 +24,7 @@ type HookWithResult = Hook & {
     hookReturn: unknown;
 };
 declare function execHook<PageContext extends PageContextExecHook>(hookName: HookName, pageContext: PageContext, preparePageContextForPublicUsage: (pageContext: PageContext) => PageContext): Promise<HookWithResult[]>;
-declare function execHookGlobal<HookArg extends PageContextPrepareMinimum | GlobalContextPrepareMinimum>(hookName: HookNameGlobal, pageConfigGlobal: PageConfigGlobalRuntime, pageContext: PageContextPrepareMinimum | null, hookArg: HookArg, prepareForPublicUsage: (hookArg: HookArg) => HookArg): Promise<void>;
+declare function execHookGlobal<HookArg extends GlobalContextPrepareMinimum>(hookName: HookNameGlobal, pageConfigGlobal: PageConfigGlobalRuntime, pageContext: PageContextPrepareMinimum | null, hookArg: HookArg, prepareForPublicUsage: (hookArg: HookArg) => HookArg): Promise<void>;
 declare function execHookDirect<PageContext extends PageContextPrepareMinimum>(hooks: Hook[], pageContext: PageContext, preparePageContextForPublicUsage: (pageContext: PageContext) => PageContext): Promise<HookWithResult[]>;
 declare function execHookDirectSingle<PageContext extends PageContextExecHook>(hook: Hook, pageContext: PageContext, preparePageContextForPublicUsage: (pageContext: PageContext) => PageContext): Promise<void>;
 declare function execHookDirectSingleWithReturn<PageContext extends PageContextExecHook>(hook: Hook, pageContext: PageContext, preparePageContextForPublicUsage: (pageContext: PageContext) => PageContext): Promise<{

package/dist/esm/shared/hooks/getHook.d.ts

@@ -14,15 +14,16 @@ import type { HookNameOld, HookNamePage, HookNameGlobal, HookName } from '../../
 import type { PageConfigGlobalRuntime, PageConfigRuntime } from '../../types/PageConfig.js';
 import type { GlobalContextPrepareMinimum } from '../prepareGlobalContextForPublicUsage.js';
 import type { PageContextPrepareMinimum } from '../preparePageContextForPublicUsage.js';
-type Hook = HookLoc & {
-    hookFn: HookFn;
+type HookArgDefault = PageContextPrepareMinimum;
+type Hook<HookArg = HookArgDefault> = HookLoc & {
+    hookFn: HookFn<HookArg>;
     hookTimeout: HookTimeout;
 };
 type HookLoc = {
     hookName: HookNameOld;
     hookFilePath: string;
 };
-type HookFn = (arg: PageContextPrepareMinimum | GlobalContextPrepareMinimum) => unknown;
+type HookFn<HookArg = HookArgDefault> = (arg: HookArg) => unknown;
 type HookTimeout = {
     error: number | false;
     warning: number | false;
@@ -32,6 +33,6 @@ declare function getHookFromPageContext(pageContext: PageContextConfig, hookName
 declare function getHookFromPageContextNew(hookName: HookName, pageContext: PageContextConfig): Hook[];
 declare function getHookFromPageConfig(pageConfig: PageConfigRuntime, hookName: HookNamePage): null | Hook;
 declare function getHookFromPageConfigGlobal(pageConfigGlobal: PageConfigGlobalRuntime, hookName: HookNameGlobal): null | Hook;
-declare function getHookFromPageConfigGlobalCumulative(pageConfigGlobal: PageConfigGlobalRuntime, hookName: HookNameGlobal): Hook[];
+declare function getHookFromPageConfigGlobalCumulative<HookArg = GlobalContextPrepareMinimum>(pageConfigGlobal: PageConfigGlobalRuntime, hookName: HookNameGlobal): Hook<HookArg>[];
 declare function getHookTimeoutDefault(hookName: HookNameOld): HookTimeout;
 declare function getHook_setIsPrerenderering(): void;

package/dist/esm/shared/route/abort.d.ts

@@ -12,6 +12,7 @@ export type { AbortStatusCode };
 export type { ErrorAbort };
 export type { PageContextFromRewrite };
 export type { UrlRedirect };
+export type { PageContextAbort };
 type RedirectStatusCode = number & Parameters<typeof redirect>[1];
 type AbortStatusCode = number & Parameters<InferTwoOverloads<typeof render>[0]>[0];
 type UrlRedirect = {

package/dist/esm/shared/route/abort.js

@@ -26,7 +26,11 @@ function redirect(url, statusCode) {
         statusCode = 302;
     }
     else {
-        if (!globalThis.__VIKE__IS_CLIENT || globalThis.__VIKE__IS_DEV) {
+        if (
+        // Tree-shaking to save client-side KBs
+        !globalThis.__VIKE__IS_CLIENT ||
+            globalThis.__VIKE__IS_DEV ||
+            globalThis.__VIKE__IS_DEBUG) {
             assertStatusCode(statusCode, [301, 302], 'redirect');
         }
         args.push(String(statusCode));
@@ -69,7 +73,11 @@ function render_(urlOrStatusCode, abortReason, abortCall, abortCaller, pageConte
         return AbortRender(pageContextAbort);
     }
     else {
-        if (!globalThis.__VIKE__IS_CLIENT || globalThis.__VIKE__IS_DEV) {
+        if (
+        // Tree-shaking to save client-side KBs
+        !globalThis.__VIKE__IS_CLIENT ||
+            globalThis.__VIKE__IS_DEV ||
+            globalThis.__VIKE__IS_DEBUG) {
             assertStatusCode(urlOrStatusCode, [401, 403, 404, 410, 429, 500, 503], 'render');
         }
         const abortStatusCode = urlOrStatusCode;
@@ -136,8 +144,8 @@ function logAbortErrorHandled(err, isProduction, pageContext) {
     });
 }
 function assertStatusCode(statusCode, expected, caller) {
-    assert(!globalThis.__VIKE__IS_CLIENT || globalThis.__VIKE__IS_DEV); // save client-side KBs
-    // double check vike:pluginReplaceGlobalThisConstants
+    assert(!globalThis.__VIKE__IS_CLIENT || globalThis.__VIKE__IS_DEV || globalThis.__VIKE__IS_DEBUG); // assert tree-shaking
+    // double check vike:pluginReplaceConstantsGlobalThis
     if (globalThis.__VIKE__IS_CLIENT) {
         assert(isBrowser());
         assert(typeof globalThis.__VIKE__IS_DEV === 'boolean');

package/dist/esm/shared/route/index.js

@@ -5,17 +5,21 @@ import { isBrowser } from '../../utils/isBrowser.js';
 if (isBrowser()) {
     assertClientRouting();
 }
-import { assert, assertUsage, isPlainObject, objectAssign } from './utils.js';
+import { assert, assertUsage, isPlainObject, objectAssign, debug } from './utils.js';
 import { resolvePrecedence } from './resolvePrecedence.js';
 import { resolveRouteString } from './resolveRouteString.js';
 import { resolveRouteFunction } from './resolveRouteFunction.js';
 import { execHookOnBeforeRoute } from './execHookOnBeforeRoute.js';
-import { debug } from './debug.js';
 import pc from '@brillout/picocolors';
 // TO-DO/next-major-release: make it sync
 async function route(pageContext, skipOnBeforeRouteHook) {
-    debug('Pages routes:', pageContext._globalContext._pageRoutes);
     const pageContextFromRoute = {};
+    if (
+    // Tree-shaking to save client-side KBs
+    !globalThis.__VIKE__IS_CLIENT ||
+        globalThis.__VIKE__IS_DEBUG) {
+        debug('vike:routing', 'Pages routes:', pageContext._globalContext._pageRoutes);
+    }
     // onBeforeRoute()
     if (!skipOnBeforeRouteHook) {
         const pageContextFromOnBeforeRouteHook = await execHookOnBeforeRoute(pageContext);
@@ -80,7 +84,12 @@ async function route(pageContext, skipOnBeforeRouteHook) {
     }));
     resolvePrecedence(routeMatches);
     const winner = routeMatches[0] ?? null;
-    debug(`Route matches for URL ${pc.cyan(urlPathname)} (in precedence order):`, routeMatches);
+    if (
+    // Tree-shaking to save client-side KBs
+    !globalThis.__VIKE__IS_CLIENT ||
+        globalThis.__VIKE__IS_DEBUG) {
+        debug('vike:routing', `Route matches for URL ${pc.cyan(urlPathname)} (in precedence order):`, routeMatches);
+    }
     // For vite-plugin-vercel https://github.com/magne4000/vite-plugin-vercel/blob/main/packages/vike-integration/vike.ts#L173
     objectAssign(pageContextFromRoute, { _routeMatch: winner });
     if (!winner) {

package/dist/esm/shared/route/utils.d.ts

@@ -13,3 +13,4 @@ export * from '../../utils/checkType.js';
 export * from '../../utils/joinEnglish.js';
 export * from '../../utils/truncateString.js';
 export * from '../../utils/isCallable.js';
+export * from '../../utils/debug.js';

package/dist/esm/shared/route/utils.js

@@ -22,3 +22,4 @@ export * from '../../utils/checkType.js';
 export * from '../../utils/joinEnglish.js';
 export * from '../../utils/truncateString.js';
 export * from '../../utils/isCallable.js';
+export * from '../../utils/debug.js';

package/dist/esm/types/Config.d.ts

@@ -48,9 +48,9 @@ import type { PassToClientPublic } from '../node/runtime/renderPage/html/seriali
 type HookNameOld = HookName | HookNameOldDesign;
 type HookName = HookNamePage | HookNameGlobal;
 type HookNamePage = 'onHydrationEnd' | 'onBeforePrerenderStart' | 'onBeforeRender' | 'onPageTransitionStart' | 'onPageTransitionEnd' | 'onRenderHtml' | 'onRenderClient' | 'guard' | 'data' | 'onData' | 'route';
-type HookNameGlobal = 'onBeforeRoute' | 'onPrerenderStart' | 'onCreatePageContext' | 'onCreateGlobalContext';
+type HookNameGlobal = 'onBeforeRoute' | 'onPrerenderStart' | 'onCreatePageContext' | 'onCreateGlobalContext' | 'onError';
 type HookNameOldDesign = 'render' | 'prerender' | 'onBeforePrerender';
-type ConfigNameBuiltIn = Exclude<keyof ConfigBuiltIn, keyof VikeVitePluginOptions | 'onBeforeRoute' | 'onPrerenderStart' | 'vite' | 'redirects'> | 'prerender' | 'serverOnlyHooks' | 'isClientRuntimeLoaded' | 'onBeforeRenderEnv' | 'dataEnv' | 'hooksTimeout' | 'clientHooks' | 'middleware';
+type ConfigNameBuiltIn = Exclude<keyof ConfigBuiltIn, keyof VikeVitePluginOptions | 'onBeforeRoute' | 'onPrerenderStart' | 'vite' | 'redirects'> | 'prerender' | 'hasServerOnlyHook' | 'isClientRuntimeLoaded' | 'onBeforeRenderEnv' | 'dataEnv' | 'hooksTimeout' | 'clientHooks' | 'middleware';
 type ConfigNameGlobal = 'onPrerenderStart' | 'onBeforeRoute' | 'prerender' | 'disableAutoFullBuild' | 'includeAssetsImportedByServer' | 'baseAssets' | 'baseServer' | 'redirects' | 'trailingSlash' | 'disableUrlNormalization' | 'vite';
 type Config = ConfigBuiltIn & Vike.Config;
 /** @deprecated This type is deprecated, see https://vike.dev/data */
@@ -268,7 +268,7 @@ type ConfigBuiltIn = {
      *
      * https://vike.dev/extends
      */
-    extends?: Config | Config[] | ImportString | ImportString[];
+    extends?: Config | ImportString | (Config | ImportString)[];
     /** Hook called before the page is rendered.
      *
      *  https://vike.dev/onBeforeRender
@@ -279,6 +279,11 @@ type ConfigBuiltIn = {
      *  https://vike.dev/onCreatePageContext
      */
     onCreatePageContext?: ((pageContext: PageContextServer) => void) | ImportString | null;
+    /** Hook called when an error occurs during server-side rendering.
+     *
+     *  https://vike.dev/onError
+     */
+    onError?: ((error: unknown) => void) | ImportString | null;
     /** Hook called when the `globalContext` object is created.
      *
      *  https://vike.dev/onCreateGlobalContext
@@ -468,6 +473,12 @@ type ConfigBuiltIn = {
      * https://vike.dev/mode
      */
     mode?: string;
+    /**
+     * Disable Vite's cache.
+     *
+     * https://vike.dev/force
+     */
+    force?: boolean;
     /**
      * Content Security Policy (CSP).
      *

package/dist/esm/utils/PROJECT_VERSION.d.ts

@@ -1 +1 @@
-export declare const PROJECT_VERSION: "0.4.240";
+export declare const PROJECT_VERSION: "0.4.241";

package/dist/esm/utils/PROJECT_VERSION.js

@@ -1,2 +1,2 @@
 // Automatically updated by @brillout/release-me
-export const PROJECT_VERSION = '0.4.240';
+export const PROJECT_VERSION = '0.4.241';

package/dist/esm/utils/assert.js

@@ -32,6 +32,7 @@ const projectTag = `[vike]`;
 const projectTagWithVersion = `[vike@${PROJECT_VERSION}]`;
 const bugTag = 'Bug';
 const numberOfStackTraceLinesToRemove = 2;
+// @__NO_SIDE_EFFECTS__
 function assert(condition, debugInfo) {
     if (condition)
         return;

package/dist/esm/utils/assertNodeVersion.js

@@ -1,7 +1,7 @@
 export { assertNodeVersion };
 import { isNodeJS } from './isNodeJS.js';
 import { assertVersion } from './assertVersion.js';
-// node_modules/vike/package.json#engines.node isn't enough as users can ignore it
+// node_modules/vike/package.json#engines.node isn't enough, as users often ignore it
 function assertNodeVersion() {
     if (!isNodeJS())
         return;

package/dist/esm/utils/assertViteVersion.d.ts

@@ -0,0 +1,2 @@
+export { assertViteVersion };
+declare function assertViteVersion(viteVersion: string): void;

package/dist/esm/utils/assertViteVersion.js

@@ -0,0 +1,11 @@
+export { assertViteVersion };
+import { assertVersion } from './assertVersion.js';
+// node_modules/vike/package.json#peerDependencies isn't enough, as users often ignore it
+function assertViteVersion(viteVersion) {
+    // - This assertion isn't reliable: the user may still use a Vite version older than 6.0.0 — see https://github.com/vitejs/vite/pull/19355
+    //   - TO-DO/eventually: let's also use this.meta.viteVersion
+    //     - this.meta.viteVersion was released in vite@7.0.0 => let's use it only after Vike requires a Vite version above 7.0.0
+    //     - https://github.com/vitejs/vite/blob/main/packages/vite/CHANGELOG.md#700-2025-06-24
+    //     - https://github.com/vitejs/vite/pull/20088
+    assertVersion('Vite', viteVersion, ['6.3.0']);
+}

package/dist/esm/utils/debug.d.ts

@@ -1,9 +1,9 @@
+export { debug };
 export { createDebugger };
+export { isDebug };
 export { isDebugActivated };
-export type { Debug };
-declare const flags: readonly ["vike:crawl", "vike:error", "vike:esbuild-resolve", "vike:pluginExtractAssets", "vike:pluginExtractExportNames", "vike:glob", "vike:globalContext", "vike:log", "vike:optimizeDeps", "vike:outDir", "vike:pageFiles", "vike:pointer-imports", "vike:resolve", "vike:routing", "vike:setup", "vike:stream", "vike:virtualFiles", "vike:vite-rpc"];
+declare const flags: ["vike", "vike:crawl", "vike:error", "vike:esbuild-resolve", "vike:pluginExtractAssets", "vike:pluginExtractExportNames", "vike:glob", "vike:globalContext", "vike:log", "vike:optimizeDeps", "vike:outDir", "vike:pageFiles", "vike:pointer-imports", "vike:requireResolve", "vike:routing", "vike:setup", "vike:stream", "vike:virtualFiles", "vike:vite-rpc"];
 type Flag = (typeof flags)[number];
-type Debug = ReturnType<typeof createDebugger>;
 type Options = {
     serialization?: {
         emptyArray?: string;
@@ -13,4 +13,6 @@ declare function createDebugger(flag: Flag, optionsGlobal?: Options): ((...msgs:
     options: (optionsLocal: Options) => (...msgs: unknown[]) => void;
     isActivated: boolean;
 };
+declare function debug(flag: Flag, ...msgs: unknown[]): void;
 declare function isDebugActivated(flag: Flag): boolean;
+declare function isDebug(): boolean;

package/dist/esm/utils/debug.js

@@ -1,18 +1,21 @@
+export { debug };
 export { createDebugger };
+export { isDebug };
 export { isDebugActivated };
 import { isCallable } from './isCallable.js';
 import { objectAssign } from './objectAssign.js';
 import { assert, assertUsage } from './assert.js';
-import { checkType } from './checkType.js';
 import { getTerminalWidth } from './getTerminalWidth.js';
 import pc from '@brillout/picocolors';
 import { isArray } from './isArray.js';
 import { isObject } from './isObject.js';
-import { setCreateDebugger } from '../shared/route/debug.js';
-import { assertIsNotBrowser } from './assertIsNotBrowser.js';
-assertIsNotBrowser();
-setCreateDebugger(createDebugger); // for isomorphic code
+// Assert tree-shaking (ensure this module is loaded on the client-side only if debug is enabled).
+assert(!globalThis.__VIKE__IS_CLIENT ||
+    globalThis.__VIKE__IS_DEBUG ||
+    // Vite doesn't do tree-shaking in dev (maybe it will with Rolldown?)
+    import.meta.env.DEV);
 const flags = [
+    'vike',
     'vike:crawl',
     'vike:error',
     'vike:esbuild-resolve',
@@ -25,7 +28,7 @@ const flags = [
     'vike:outDir',
     'vike:pageFiles',
     'vike:pointer-imports',
-    'vike:resolve',
+    'vike:requireResolve',
     'vike:routing',
     'vike:setup',
     'vike:stream',
@@ -33,14 +36,12 @@ const flags = [
     'vike:vite-rpc',
 ];
 const flagsSkipWildcard = ['vike:log'];
-const flagRegex = /\bvike:[a-zA-Z-]+/g;
 // We purposely read process.env.DEBUG early, in order to avoid users from the temptation to set process.env.DEBUG with JavaScript, since reading & writing process.env.DEBUG dynamically leads to inconsistencies such as https://github.com/vikejs/vike/issues/2239
 const DEBUG = getDEBUG() ?? '';
 if (isDebug())
     Error.stackTraceLimit = Infinity;
 assertFlagsActivated();
 function createDebugger(flag, optionsGlobal) {
-    checkType(flag);
     assert(flags.includes(flag));
     const debugWithOptions = (optionsLocal) => {
         return (...msgs) => {
@@ -52,6 +53,9 @@ function createDebugger(flag, optionsGlobal) {
     objectAssign(debug, { options: debugWithOptions, isActivated: isDebugActivated(flag) });
     return debug;
 }
+function debug(flag, ...msgs) {
+    return debug_(flag, {}, ...msgs);
+}
 function debug_(flag, options, ...msgs) {
     if (!isDebugActivated(flag))
         return;
@@ -80,10 +84,9 @@ function debug_(flag, options, ...msgs) {
     });
 }
 function isDebugActivated(flag) {
-    checkType(flag);
     assert(flags.includes(flag));
-    const { flagsActivated, all } = getFlagsActivated();
-    const isActivated = flagsActivated.includes(flag) || (all && !flagsSkipWildcard.includes(flag));
+    const { flagsActivated, isAll } = getFlagsActivated();
+    const isActivated = flagsActivated.includes(flag) || (isAll && !flagsSkipWildcard.includes(flag));
     return isActivated;
 }
 function formatMsg(info, options, padding, position) {
@@ -153,13 +156,14 @@ function assertFlagsActivated() {
     });
 }
 function getFlagsActivated() {
-    const flagsActivated = DEBUG.match(flagRegex) ?? [];
-    const all = DEBUG.includes('vike:*');
-    return { flagsActivated, all };
+    const flagsActivated = DEBUG.match(/\bvike:[a-zA-Z-]+/g) ?? [];
+    const isAll = DEBUG.includes('vike:*');
+    const isGlobal = /\bvike\b([^:]|$)/.test(DEBUG);
+    return { flagsActivated, isAll, isGlobal };
 }
 function isDebug() {
-    const { flagsActivated, all } = getFlagsActivated();
-    return all || flagsActivated.length > 0;
+    const { flagsActivated, isAll, isGlobal } = getFlagsActivated();
+    return isAll || flagsActivated.length > 0 || isGlobal;
 }
 function getDEBUG() {
     let DEBUG;

package/dist/esm/utils/getGlobalObject.d.ts

@@ -1,7 +1,11 @@
 export { getGlobalObject };
 import type { VikeGlobalInternal } from '../types/VikeGlobalInternal.js';
 type ModuleId = `${string}.ts`;
-/** Share information across module instances. */
+/**
+ * Share information across module instances.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
 declare function getGlobalObject<T extends Record<string, unknown> = never>(moduleId: ModuleId, defaultValue: T): T;
 declare global {
     var _vike: VikeGlobalInternal;

package/dist/esm/utils/getGlobalObject.js

@@ -1,5 +1,9 @@
 export { getGlobalObject };
-/** Share information across module instances. */
+/**
+ * Share information across module instances.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
 function getGlobalObject(moduleId, defaultValue) {
     const globals = getGlobals();
     const globalObject = (globals[moduleId] ?? (globals[moduleId] = defaultValue));

package/dist/esm/utils/isVikeReactApp.js

@@ -1,5 +1,6 @@
 export function isVikeReactApp() {
     const g = globalThis;
-    // Set by vike-react https://github.com/vikejs/vike-react/blob/23e92434424f10e7e742b6bf587edee5aa8832df/packages/vike-react/src/renderer/onRenderHtml.tsx#L75
+    // Set by vike-react
+    // https://github.com/vikejs/vike-react/blob/23e92434424f10e7e742b6bf587edee5aa8832df/packages/vike-react/src/renderer/onRenderHtml.tsx#L75
     return !!g._isVikeReactApp;
 }

package/dist/esm/utils/requireResolve.js

@@ -17,7 +17,7 @@ const importMetaUrl = import.meta.url;
 assertPosixPath(importMetaUrl);
 assertIsNotBrowser();
 assertIsNotProductionRuntime();
-const debug = createDebugger('vike:resolve');
+const debug = createDebugger('vike:requireResolve');
 // - We still can't use import.meta.resolve() as of 23.1.0 (November 2024) because `parent` argument requires an experimental flag.
 //   - https://stackoverflow.com/questions/54977743/do-require-resolve-for-es-modules#comment139581675_62272600
 // - Passing context to createRequire(context) isn't equivalent to passing it to the `paths` argument of require.resolve()