vike 0.4.239 → 0.4.240-commit-bac5dee

package/dist/esm/node/vite/plugins/pluginVirtualFiles.js

@@ -2,63 +2,81 @@ export { pluginVirtualFiles };
 import { normalizePath } from 'vite';
 import { generateVirtualFilePageEntry } from './pluginVirtualFiles/generateVirtualFilePageEntry.js';
 import { generateVirtualFileGlobalEntryWithOldDesign } from './pluginVirtualFiles/generateVirtualFileGlobalEntryWithOldDesign.js';
-import { assert, assertPosixPath, isScriptFile, addVirtualFileIdPrefix, isVirtualFileId, removeVirtualFileIdPrefix, } from '../utils.js';
+import { assert, assertPosixPath, isScriptFile, addVirtualFileIdPrefix, isVirtualFileId, removeVirtualFileIdPrefix, escapeRegex, virtualFileIdPrefix1, virtualFileIdPrefix2, } from '../utils.js';
 import { parseVirtualFileId } from '../../shared/virtualFileId.js';
 import { reloadVikeConfig, isV1Design, getVikeConfigInternalOptional } from '../shared/resolveVikeConfigInternal.js';
 import pc from '@brillout/picocolors';
 import { logConfigInfo } from '../shared/loggerNotProd.js';
 import { getModuleFilePathAbsolute } from '../shared/getFilePath.js';
-import { updateUserFiles } from '../../runtime/globalContext.js';
+import { isRunnable, updateUserFiles } from '../../runtime/globalContext.js';
 import { isPlusFile } from '../shared/resolveVikeConfigInternal/crawlPlusFiles.js';
 import { isTemporaryBuildFile } from '../shared/resolveVikeConfigInternal/transpileAndExecuteFile.js';
 import { getVikeConfigError } from '../../shared/getVikeConfigError.js';
+const filterRolldown = {
+    id: {
+        include: new RegExp(`^(${escapeRegex(virtualFileIdPrefix1)}|${escapeRegex(virtualFileIdPrefix2)})`),
+    },
+};
+const filterFunction = (id) => isVirtualFileId(id);
 function pluginVirtualFiles() {
     let config;
-    return {
-        name: 'vike:pluginVirtualFiles',
-        async configResolved(config_) {
-            config = config_;
-            // TO-DO/next-major-release: remove
-            if (!isV1Design())
-                config.experimental.importGlobRestoreExtension = true;
+    return [
+        {
+            name: 'vike:pluginVirtualFiles',
+            configResolved: {
+                async handler(config_) {
+                    config = config_;
+                    // TO-DO/next-major-release: remove
+                    if (!isV1Design())
+                        config.experimental.importGlobRestoreExtension = true;
+                },
+            },
+            resolveId: {
+                filter: filterRolldown,
+                handler(id) {
+                    assert(filterFunction(id));
+                    return addVirtualFileIdPrefix(id);
+                },
+            },
+            handleHotUpdate: {
+                async handler(ctx) {
+                    try {
+                        return await handleHotUpdate(ctx, config);
+                    }
+                    catch (err) {
+                        // Vite swallows errors thrown by handleHotUpdate()
+                        console.error(err);
+                        throw err;
+                    }
+                },
+            },
+            load: {
+                filter: filterRolldown,
+                async handler(id, options) {
+                    assert(filterFunction(id));
+                    id = removeVirtualFileIdPrefix(id);
+                    const isDev = config._isDev;
+                    assert(typeof isDev === 'boolean');
+                    const idParsed = parseVirtualFileId(id);
+                    if (idParsed) {
+                        if (idParsed.type === 'page-entry') {
+                            const code = await generateVirtualFilePageEntry(id, isDev);
+                            return code;
+                        }
+                        if (idParsed.type === 'global-entry') {
+                            const code = await generateVirtualFileGlobalEntryWithOldDesign(id, options, config, this.environment, isDev);
+                            return code;
+                        }
+                    }
+                },
+            },
+            configureServer: {
+                handler(server) {
+                    handleFileAddRemove(server, config);
+                },
+            },
         },
-        resolveId(id) {
-            if (isVirtualFileId(id)) {
-                return addVirtualFileIdPrefix(id);
-            }
-        },
-        async handleHotUpdate(ctx) {
-            try {
-                return await handleHotUpdate(ctx, config);
-            }
-            catch (err) {
-                // Vite swallows errors thrown by handleHotUpdate()
-                console.error(err);
-                throw err;
-            }
-        },
-        async load(id, options) {
-            if (!isVirtualFileId(id))
-                return undefined;
-            id = removeVirtualFileIdPrefix(id);
-            const isDev = config._isDev;
-            assert(typeof isDev === 'boolean');
-            const idParsed = parseVirtualFileId(id);
-            if (idParsed) {
-                if (idParsed.type === 'page-entry') {
-                    const code = await generateVirtualFilePageEntry(id, isDev);
-                    return code;
-                }
-                if (idParsed.type === 'global-entry') {
-                    const code = await generateVirtualFileGlobalEntryWithOldDesign(id, options, config, this.environment, isDev);
-                    return code;
-                }
-            }
-        },
-        configureServer(server) {
-            handleFileAddRemove(server, config);
-        },
-    };
+    ];
 }
 function handleFileAddRemove(server, config) {
     server.watcher.prependListener('add', (f) => listener(f, false));
@@ -125,7 +143,9 @@ async function handleHotUpdate(ctx, config) {
             // Ensure we invalidate `file` *before* server.ssrLoadModule() in updateUserFiles()
             // Vite already invalidates it, but *after* handleHotUpdate() and thus after server.ssrLoadModule()
             ctx.modules.forEach((mod) => server.moduleGraph.invalidateModule(mod));
-            updateUserFiles();
+            if (isRunnable(server)) {
+                await updateUserFiles();
+            }
         }
     }
 }

package/dist/esm/node/vite/plugins/pluginWorkaroundCssModuleHmr.d.ts

@@ -1,3 +1,3 @@
 export { pluginWorkaroundCssModuleHmr };
 import type { Plugin } from 'vite';
-declare function pluginWorkaroundCssModuleHmr(): Plugin;
+declare function pluginWorkaroundCssModuleHmr(): Plugin[];

package/dist/esm/node/vite/plugins/pluginWorkaroundCssModuleHmr.js

@@ -1,13 +1,17 @@
 export { pluginWorkaroundCssModuleHmr };
 function pluginWorkaroundCssModuleHmr() {
-    return {
-        name: 'vike:pluginWorkaroundCssModuleHmr',
-        handleHotUpdate(ctx) {
-            // prevent full reload due to non self-accepting css module.
-            // here only "?direct" module should be filtered out as it doesn't have a parent module.
-            if (ctx.file.includes('module.css')) {
-                return ctx.modules.filter((m) => !m.id?.includes('?direct'));
-            }
+    return [
+        {
+            name: 'vike:pluginWorkaroundCssModuleHmr',
+            handleHotUpdate: {
+                handler(ctx) {
+                    // prevent full reload due to non self-accepting css module.
+                    // here only "?direct" module should be filtered out as it doesn't have a parent module.
+                    if (ctx.file.includes('module.css')) {
+                        return ctx.modules.filter((m) => !m.id?.includes('?direct'));
+                    }
+                },
+            },
         },
-    };
+    ];
 }

package/dist/esm/node/vite/plugins/pluginWorkaroundVite6HmrRegression.d.ts

@@ -1,3 +1,3 @@
 export { pluginWorkaroundVite6HmrRegression };
 import type { Plugin } from 'vite';
-declare function pluginWorkaroundVite6HmrRegression(): Plugin;
+declare function pluginWorkaroundVite6HmrRegression(): Plugin[];

package/dist/esm/node/vite/plugins/pluginWorkaroundVite6HmrRegression.js

@@ -4,30 +4,32 @@ export { pluginWorkaroundVite6HmrRegression };
 // Workaround seems to work for docs page /banner (which is HTML-only)
 // But doesn't seem to work for /examples/render-modes/ (see https://github.com/vikejs/vike/pull/2069 commit `renable HMR test for HTML-only`)
 function pluginWorkaroundVite6HmrRegression() {
-    return {
-        name: 'vike:pluginWorkaroundVite6HmrRegression',
-        enforce: 'post',
-        hotUpdate: {
-            order: 'post',
-            handler({ modules, server, timestamp }) {
-                if (this.environment.name !== 'ssr')
-                    return;
-                let hasSsrOnlyModules = false;
-                const invalidatedModules = new Set();
-                for (const mod of modules) {
-                    if (mod.id == null)
-                        continue;
-                    const clientModule = server.environments.client.moduleGraph.getModuleById(mod.id);
-                    if (clientModule != null)
-                        continue;
-                    this.environment.moduleGraph.invalidateModule(mod, invalidatedModules, timestamp, true);
-                    hasSsrOnlyModules = true;
-                }
-                if (hasSsrOnlyModules) {
-                    server.ws.send({ type: 'full-reload' });
-                    return [];
-                }
+    return [
+        {
+            name: 'vike:pluginWorkaroundVite6HmrRegression',
+            enforce: 'post',
+            hotUpdate: {
+                order: 'post',
+                handler({ modules, server, timestamp }) {
+                    if (this.environment.name !== 'ssr')
+                        return;
+                    let hasSsrOnlyModules = false;
+                    const invalidatedModules = new Set();
+                    for (const mod of modules) {
+                        if (mod.id == null)
+                            continue;
+                        const clientModule = server.environments.client.moduleGraph.getModuleById(mod.id);
+                        if (clientModule != null)
+                            continue;
+                        this.environment.moduleGraph.invalidateModule(mod, invalidatedModules, timestamp, true);
+                        hasSsrOnlyModules = true;
+                    }
+                    if (hasSsrOnlyModules) {
+                        server.ws.send({ type: 'full-reload' });
+                        return [];
+                    }
+                },
             },
         },
-    };
+    ];
 }

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

@@ -5,5 +5,5 @@ declare function getMagicString(code: string, id: string): {
     getMagicStringResult: () => {
         code: string;
         map: import("magic-string").SourceMap;
-    };
+    } | undefined;
 };

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

@@ -4,6 +4,8 @@ import MagicString from 'magic-string';
 function getMagicString(code, id) {
     const magicString = new MagicString(code);
     const getMagicStringResult = () => {
+        if (!magicString.hasChanged())
+            return undefined;
         return {
             code: magicString.toString(),
             map: magicString.generateMap({ hires: true, source: id }),

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

@@ -96,11 +96,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

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

@@ -6,11 +6,11 @@ export type GlobalContextInternal = GlobalContextServerInternal | GlobalContextC
 import type { PageFile } from './getPageFiles.js';
 import type { PageConfigRuntime } from '../types/PageConfig.js';
 import type { GlobalContextServerInternal } from '../node/runtime/globalContext.js';
-import type { GlobalContextClientInternal } from '../client/runtime-client-routing/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 Record<string, any>, GlobalContextAddedAsync extends Record<string, any>>(virtualFileExportsGlobalEntry: unknown, globalObject: {
-    globalContext?: Record<string, unknown>;
+declare function createGlobalContextShared<GlobalContextAdded extends {}, GlobalContextAddedAsync extends {}>(virtualFileExportsGlobalEntry: unknown, globalObject: {
+    globalContext?: {};
     onCreateGlobalContextHooks?: Hook[];
     previousCreateGlobalContextPromise?: Promise<void>;
 }, addGlobalContext?: (globalContext: GlobalContextBase) => GlobalContextAdded, addGlobalContextTmp?: (globalContext: GlobalContextBase) => Promise<GlobalContextAdded>, addGlobalContextAsync?: (globalContext: GlobalContextBase) => Promise<GlobalContextAddedAsync>): Promise<{
@@ -64,7 +64,7 @@ declare function createGlobalContextShared<GlobalContextAdded extends Record<str
     _pageConfigs: PageConfigRuntime[];
     _pageConfigGlobal: import("../types/PageConfig.js").PageConfigGlobalRuntime;
     _allPageIds: string[];
-} & GlobalContextAdded & GlobalContextAddedAsync>;
+} & GlobalContextAdded & Awaited<GlobalContextAddedAsync>>;
 type GlobalContextBasePublic = Pick<GlobalContextBase, 'config' | 'pages' | 'isGlobalContext'>;
 type GlobalContextBase = ReturnType<typeof createGlobalContextBase>;
 declare function createGlobalContextBase(virtualFileExportsGlobalEntry: unknown): {

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

@@ -13,7 +13,7 @@ export type { ErrorAbort };
 export type { PageContextFromRewrite };
 export type { UrlRedirect };
 type RedirectStatusCode = number & Parameters<typeof redirect>[1];
-type AbortStatusCode = number & Parameters<typeof render>[0];
+type AbortStatusCode = number & Parameters<InferTwoOverloads<typeof render>[0]>[0];
 type UrlRedirect = {
     url: string;
     statusCode: RedirectStatusCode;
@@ -36,16 +36,23 @@ declare function redirect(url: string, statusCode?: 301 | 302): AbortRedirect;
  *
  * https://vike.dev/render
  *
- * @param abortStatusCode
- * One of the following:
- *   `401` Unauthorized (user isn't logged in)
- *   `403` Forbidden (user is logged in but isn't allowed)
- *   `404` Not Found
- *   `410` Gone (use this instead of `404` if the page existed in the past, see https://github.com/vikejs/vike/issues/1097#issuecomment-1695260887)
- *   `429` Too Many Requests (rate limiting)
- *   `500` Internal Server Error (your client or server has a bug)
- *   `503` Service Unavailable (server is overloaded, or a third-party API isn't responding)
- * @param abortReason Sets `pageContext.abortReason` which is usually used by the error page to show a message to the user, see https://vike.dev/error-page
+ *
+ * **Recommended** status codes:
+ *   `401` — Unauthorized (user isn't logged in)
+ *   `403` — Forbidden (user is logged in but isn't allowed)
+ *   `404` — Not Found
+ *   `410` — Gone (use this instead of `404` if the page existed in the past, see https://github.com/vikejs/vike/issues/1097#issuecomment-1695260887)
+ *   `429` — Too Many Requests (rate limiting)
+ *   `500` — Internal Server Error (your client or server has a bug)
+ *   `503` — Service Unavailable (server is overloaded, or a third-party API isn't responding)
+ *
+ * **Not recommended** status codes:
+ *   `400` — See https://github.com/vikejs/vike/issues/1008#issuecomment-3270894445
+ *   Other status codes — See https://github.com/vikejs/vike/issues/1008
+ *
+ * @param abortStatusCode - One of the recommended status codes listed above.
+ *
+ * @param abortReason - Sets `pageContext.abortReason` which is usually used by the error page to show a message to the user, see https://vike.dev/error-page
  */
 declare function render(abortStatusCode: 401 | 403 | 404 | 410 | 429 | 500 | 503, abortReason?: AbortReason): Error;
 /**
@@ -106,3 +113,7 @@ type PageContextFromAllRewrites = {
 };
 declare function getPageContextFromAllRewrites(pageContextsFromRewrite: PageContextFromRewrite[]): PageContextFromAllRewrites;
 declare function assertNoInfiniteAbortLoop(rewriteCount: number, redirectCount: number): void;
+type InferTwoOverloads<F extends Function> = F extends {
+    (...a1: infer A1): infer R1;
+    (...a0: infer A0): infer R0;
+} ? [(...a1: A1) => R1, (...a0: A0) => R0] : never;

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

@@ -8,7 +8,7 @@ export { getPageContextFromAllRewrites };
 export { AbortRender };
 export { assertNoInfiniteAbortLoop };
 import { isUserHookError } from '../hooks/execHook.js';
-import { assert, assertInfo, assertUsage, assertUsageUrlPathnameAbsolute, assertUsageUrlRedirectTarget, assertWarning, checkType, hasProp, joinEnglish, objectAssign, truncateString, } from './utils.js';
+import { assert, assertInfo, assertUsage, assertUsageUrlPathnameAbsolute, assertUsageUrlRedirectTarget, assertWarning, checkType, hasProp, isBrowser, joinEnglish, objectAssign, truncateString, } from './utils.js';
 import pc from '@brillout/picocolors';
 /**
  * Abort the rendering of the current page, and redirect the user to another URL instead.
@@ -26,7 +26,13 @@ function redirect(url, statusCode) {
         statusCode = 302;
     }
     else {
-        assertStatusCode(statusCode, [301, 302], 'redirect');
+        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));
     }
     const pageContextAbort = {};
@@ -67,8 +73,14 @@ function render_(urlOrStatusCode, abortReason, abortCall, abortCaller, pageConte
         return AbortRender(pageContextAbort);
     }
     else {
+        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;
-        assertStatusCode(urlOrStatusCode, [401, 403, 404, 410, 429, 500, 503], 'render');
         objectAssign(pageContextAbort, {
             abortStatusCode,
             is404: abortStatusCode === 404,
@@ -132,8 +144,36 @@ function logAbortErrorHandled(err, isProduction, pageContext) {
     });
 }
 function assertStatusCode(statusCode, expected, caller) {
-    const expectedEnglish = joinEnglish(expected.map((s) => s.toString()), 'or');
-    assertWarning(expected.includes(statusCode), `Unepexected status code ${statusCode} passed to ${caller}(), we recommend ${expectedEnglish} instead. (Or reach out at https://github.com/vikejs/vike/issues/1008 if you believe ${statusCode} should be added.)`, { onlyOnce: true });
+    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');
+        assert(typeof globalThis.__VIKE__IS_CLIENT === 'boolean');
+        assert(import.meta.env.SSR === false);
+        assert(import.meta.env.DEV === globalThis.__VIKE__IS_DEV);
+    }
+    else {
+        assert(!isBrowser());
+        if (import.meta.env) {
+            assert(typeof globalThis.__VIKE__IS_DEV === 'boolean');
+            assert(typeof globalThis.__VIKE__IS_CLIENT === 'boolean');
+            assert(import.meta.env.SSR === true);
+            assert(import.meta.env.DEV === globalThis.__VIKE__IS_DEV);
+        }
+        else {
+            // import.meta.env isn't defined when 'vike' is ssr.external
+        }
+    }
+    const expectedEnglish = joinEnglish(expected.map((s) => pc.bold(String(s))), 'or');
+    const statusCodeWithColor = pc.bold(String(statusCode));
+    if (statusCode === 400) {
+        assert(!expected.includes(statusCode));
+        assertWarning(false, `We recommend against using the status code ${statusCodeWithColor} passed to ${caller}() — we recommend using ${pc.bold('404')} instead, see https://github.com/vikejs/vike/issues/1008#issuecomment-3270894445`, { onlyOnce: true, showStackTrace: true });
+    }
+    else {
+        assertWarning(expected.includes(statusCode), `Unexpected status code ${statusCodeWithColor} passed to ${caller}() — we recommend using ${expectedEnglish} instead. (Or reach out at https://github.com/vikejs/vike/issues/1008 if you believe ${statusCodeWithColor} should be added.)`, { onlyOnce: true, showStackTrace: true });
+    }
 }
 function getPageContextFromAllRewrites(pageContextsFromRewrite) {
     assertNoInfiniteLoop(pageContextsFromRewrite);

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

@@ -50,7 +50,7 @@ type HookName = HookNamePage | HookNameGlobal;
 type HookNamePage = 'onHydrationEnd' | 'onBeforePrerenderStart' | 'onBeforeRender' | 'onPageTransitionStart' | 'onPageTransitionEnd' | 'onRenderHtml' | 'onRenderClient' | 'guard' | 'data' | 'onData' | 'route';
 type HookNameGlobal = 'onBeforeRoute' | 'onPrerenderStart' | 'onCreatePageContext' | 'onCreateGlobalContext';
 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 */

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

@@ -19,8 +19,8 @@ import type { From, PageContextConfig, Source, Sources } from '../shared/page-co
 import type { Config } from './Config.js';
 import type { AbortStatusCode } from '../shared/route/abort.js';
 import type { GlobalContextServer } from '../node/runtime/globalContext.js';
-import type { GlobalContextClient } from '../client/runtime-client-routing/globalContext.js';
-import type { GlobalContextClientWithServerRouting } from '../client/runtime-server-routing/globalContext.js';
+import type { GlobalContextClient } from '../client/runtime-client-routing/getGlobalContextClientInternal.js';
+import type { GlobalContextClientWithServerRouting } from '../client/runtime-server-routing/getGlobalContextClientInternal.js';
 type PageContextServer<Data = unknown> = PageContextBuiltInServer<Data> & Vike.PageContext & Vike.PageContextServer;
 type PageContext<Data = unknown> = PageContextClient<Data> | PageContextServer<Data>;
 type PageContextClient<Data = unknown> = PageContextBuiltInClientWithClientRouting<Data> & Vike.PageContext & Vike.PageContextClient;
@@ -137,9 +137,9 @@ type PageContextBuiltInCommon<Data> = PageContextConfig & {
 };
 type PageContextBuiltInServer<Data> = PageContextBuiltInCommon<Data> & PageContextUrlServer & {
     /**
-     * Whether the page is being rendered on the client-side or server-side / pre-rendered.
-     *
-     * We recommend using `import.meta.env.SSR` instead, see https://vike.dev/pageContext#isClientSide
+     * Whether the environment is the client-side:
+     * - In the browser, the value is `true`.
+     * - Upon SSR and pre-rendering, the value is `false`.
      *
      * https://vike.dev/pageContext#isClientSide
      */
@@ -210,9 +210,9 @@ type PageContextBuiltInClientWithServerRouting<Data> = Partial<PageContextBuiltI
 };
 type PageContextClientCommon = {
     /**
-     * Whether the page is being rendered on the client-side, or rendered on the server-side / pre-rendered.
-     *
-     * In order to save client-side KBs, we recommend using `import.meta.env.SSR` whenever possible instead, see https://vike.dev/pageContext#isClientSide
+     * Whether the environment is the client-side:
+     * - In the browser, the value is `true`.
+     * - Upon SSR and pre-rendering, the value is `false`.
      *
      * https://vike.dev/pageContext#isClientSide
      */

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

@@ -1 +1 @@
-export declare const PROJECT_VERSION: "0.4.239";
+export declare const PROJECT_VERSION: "0.4.240-commit-bac5dee";

package/dist/esm/utils/PROJECT_VERSION.js

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

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/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;