vike 0.4.239-commit-95ab407 → 0.4.240-commit-bac5dee

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/node/runtime/globalContext.js

@@ -261,6 +261,7 @@ async function loadProdBuildEntry(outDir) {
 // https://github.com/vikejs/vike/blob/8c350e8105a626469e87594d983090919e82099b/packages/vike/node/vite/plugins/pluginBuild/pluginProdBuildEntry.ts#L47
 async function setGlobalContext_prodBuildEntry(prodBuildEntry) {
     debug('setGlobalContext_prodBuildEntry()');
+    assert(!isNonRunnableDev());
     assertProdBuildEntry(prodBuildEntry);
     globalObject.prodBuildEntry = prodBuildEntry;
     globalObject.prodBuildEntryPrevious = prodBuildEntry;
@@ -359,13 +360,14 @@ async function updateUserFiles() {
     }
     else {
         try {
-            /* We use __VIKE__DYNAMIC_IMPORT instead of directly using import() to workaround what seems to be a Vite HMR bug:
-               ```js
-               assert(false)
-               // This line breaks the HMR of regular (runnable) apps, even though (as per the assert() above) it's never run. It seems to be a Vite bug: handleHotUpdate() receives an empty `modules` list.
-               import('virtual:vike:global-entry:server')
-               ```
-            */
+            // We don't directly use import() because:
+            // - Avoid Cloudflare Workers (without @cloudflare/vite-plugin) to try to bundle `import('virtual:id')`.
+            // - Using import() seems to lead to a Vite HMR bug:
+            //   ```js
+            //   assert(false)
+            //   // This line breaks the HMR of regular (runnable) apps, even though (as per the assert() above) it's never run. It seems to be a Vite bug: handleHotUpdate() receives an empty `modules` list.
+            //   import('virtual:vike:global-entry:server')
+            //   ```
             virtualFileExportsGlobalEntry = await __VIKE__DYNAMIC_IMPORT('virtual:vike:global-entry:server');
         }
         catch (err_) {
@@ -563,7 +565,7 @@ function isProdOptional() {
     // getGlobalContextAsync(isProduction)
     const no4 = globalObject.isProductionAccordingToUser === false;
     // @cloudflare/vite-plugin
-    const no5 = isNonRunnableDev() === true;
+    const no5 = isNonRunnableDev();
     const no = no1 || no2 || no3 || no4 || no5;
     const debug = { yes1, yes2, yes3, yes4, yes5, yes6, no1, no2, no3, no4, no5 };
     assert(typeof yes === 'boolean', debug);

package/dist/esm/node/vite/index.js

@@ -6,7 +6,7 @@ export { getVikeConfig } from './shared/resolveVikeConfigInternal.js';
 export { PROJECT_VERSION as version } from './utils.js';
 import { getClientEntrySrcDev } from './shared/getClientEntrySrcDev.js';
 import { setGetClientEntrySrcDev } from '../runtime/renderPage/getPageAssets/retrievePageAssetsDev.js';
-import { assertUsage } from './utils.js';
+import { assertIsNotProductionRuntime, assertUsage } from './utils.js';
 import pc from '@brillout/picocolors';
 import { pluginPreview } from './plugins/pluginPreview.js';
 import { pluginDev } from './plugins/pluginDev.js';
@@ -16,22 +16,24 @@ import { pluginExtractExportNames } from './plugins/pluginExtractExportNames.js'
 import { pluginSetGlobalContext } from './plugins/pluginSetGlobalContext.js';
 import { pluginCommon } from './plugins/pluginCommon.js';
 import { pluginBaseUrls } from './plugins/pluginBaseUrls.js';
-import { pluginEnvVars } from './plugins/pluginEnvVars.js';
+import { pluginReplaceConstantsEnvVars } from './plugins/pluginReplaceConstantsEnvVars.js';
 import { pluginFileEnv } from './plugins/pluginFileEnv.js';
 import { pluginWorkaroundCssModuleHmr } from './plugins/pluginWorkaroundCssModuleHmr.js';
 import { pluginWorkaroundVite6HmrRegression } from './plugins/pluginWorkaroundVite6HmrRegression.js';
-import { pluginReplaceIsClientSide } from './plugins/pluginReplaceIsClientSide.js';
-import { pluginReplaceGlobalThisConstants } from './plugins/pluginReplaceGlobalThisConstants.js';
-import { pluginNonRunnableDev } from './plugins/pluginNonRunnableDev.js';
-import { pluginBuildApp } from './plugins/pluginBuild/pluginBuildApp.js';
-import { pluginDistPackageJsonFile } from './plugins/pluginBuild/pluginDistPackageJsonFile.js';
-import { pluginSuppressRollupWarning } from './plugins/pluginBuild/pluginSuppressRollupWarning.js';
-import { pluginDistFileNames } from './plugins/pluginBuild/pluginDistFileNames.js';
-import { pluginProdBuildEntry } from './plugins/pluginBuild/pluginProdBuildEntry.js';
-import { pluginBuildConfig } from './plugins/pluginBuild/pluginBuildConfig.js';
-import { pluginModuleBanner } from './plugins/pluginBuild/pluginModuleBanner.js';
+import { pluginReplaceConstantsPageContext } from './plugins/pluginReplaceConstantsPageContext.js';
+import { pluginReplaceConstantsGlobalThis } from './plugins/pluginReplaceConstantsGlobalThis.js';
+import { pluginViteRPC } from './plugins/non-runnable-dev/pluginViteRPC.js';
+import { pluginBuildApp } from './plugins/build/pluginBuildApp.js';
+import { pluginDistPackageJsonFile } from './plugins/build/pluginDistPackageJsonFile.js';
+import { pluginSuppressRollupWarning } from './plugins/build/pluginSuppressRollupWarning.js';
+import { pluginDistFileNames } from './plugins/build/pluginDistFileNames.js';
+import { pluginProdBuildEntry } from './plugins/build/pluginProdBuildEntry.js';
+import { pluginBuildConfig } from './plugins/build/pluginBuildConfig.js';
+import { pluginModuleBanner } from './plugins/build/pluginModuleBanner.js';
+import { pluginReplaceConstantsNonRunnableDev } from './plugins/non-runnable-dev/pluginReplaceConstantsNonRunnableDev.js';
 // We don't call this in ./onLoad.ts to avoid a cyclic dependency with utils.ts
 setGetClientEntrySrcDev(getClientEntrySrcDev);
+assertIsNotProductionRuntime();
 // Return `PluginInterop` instead of `Plugin` to avoid type mismatch upon different Vite versions
 function plugin(vikeVitePluginOptions = {}) {
     const plugins = [
@@ -44,13 +46,13 @@ function plugin(vikeVitePluginOptions = {}) {
         ...pluginExtractExportNames(),
         ...pluginSetGlobalContext(),
         ...pluginBaseUrls(),
-        ...pluginEnvVars(),
+        ...pluginReplaceConstantsEnvVars(),
         ...pluginFileEnv(),
         ...pluginWorkaroundCssModuleHmr(),
         ...pluginWorkaroundVite6HmrRegression(),
-        ...pluginReplaceIsClientSide(),
-        ...pluginReplaceGlobalThisConstants(),
-        ...pluginNonRunnableDev(),
+        ...pluginReplaceConstantsPageContext(),
+        ...pluginReplaceConstantsGlobalThis(),
+        ...pluginNonRunnabeDev(),
     ];
     Object.assign(plugins, { _vikeVitePluginOptions: vikeVitePluginOptions });
     return plugins;
@@ -66,6 +68,9 @@ function pluginBuild() {
         ...pluginModuleBanner(),
     ];
 }
+function pluginNonRunnabeDev() {
+    return [...pluginViteRPC(), ...pluginReplaceConstantsNonRunnableDev()];
+}
 // Error upon wrong usage
 Object.defineProperty(plugin, 'apply', {
     enumerable: true,

package/dist/esm/node/vite/plugins/non-runnable-dev/pluginReplaceConstantsNonRunnableDev.d.ts

@@ -0,0 +1,7 @@
+export { pluginReplaceConstantsNonRunnableDev };
+import type { Plugin } from 'vite';
+declare global {
+    var __VIKE__IS_NON_RUNNABLE_DEV: undefined | true;
+    var __VIKE__DYNAMIC_IMPORT: (module: `virtual:${string}`) => Promise<Record<string, unknown>>;
+}
+declare function pluginReplaceConstantsNonRunnableDev(): Plugin[];

package/dist/esm/node/vite/plugins/non-runnable-dev/pluginReplaceConstantsNonRunnableDev.js

@@ -0,0 +1,47 @@
+export { pluginReplaceConstantsNonRunnableDev };
+import { isRunnableDevEnvironment, isDevCheck } from '../../utils.js';
+import { getMagicString } from '../../shared/getMagicString.js';
+// - We cannot use [`define`](https://vite.dev/config/shared-options.html#define) because we don't have access to `this.environment` and therefore we cannot call `isRunnableDevEnvironment(this.environment)` inside a configEnvironment() hook.
+// - We cannot use [`filter.id`](https://rolldown.rs/plugins/hook-filters) because Vite's optimizeDeps bundles packages (e.g. `vike` or `telefunc`) into node_modules/.vite/deps_ssr/chunk-WBC5FHD7.js
+const IS_NON_RUNNABLE_DEV = 'globalThis.__VIKE__IS_NON_RUNNABLE_DEV';
+const DYNAMIC_IMPORT = '__VIKE__DYNAMIC_IMPORT';
+function pluginReplaceConstantsNonRunnableDev() {
+    return [
+        {
+            name: 'vike:pluginReplaceConstantsNonRunnableDev:IS_NON_RUNNABLE_DEV',
+            apply: (_, configEnv) => isDevCheck(configEnv),
+            transform: {
+                filter: {
+                    code: {
+                        include: IS_NON_RUNNABLE_DEV,
+                    },
+                },
+                handler(code, id) {
+                    if (isRunnableDevEnvironment(this.environment))
+                        return;
+                    const { magicString, getMagicStringResult } = getMagicString(code, id);
+                    magicString.replaceAll(IS_NON_RUNNABLE_DEV, JSON.stringify(true));
+                    return getMagicStringResult();
+                },
+            },
+        },
+        {
+            name: 'vike:pluginReplaceConstantsNonRunnableDev:DYNAMIC_IMPORT',
+            apply: (_, configEnv) => isDevCheck(configEnv),
+            transform: {
+                filter: {
+                    code: {
+                        include: DYNAMIC_IMPORT,
+                    },
+                },
+                handler(code, id) {
+                    if (isRunnableDevEnvironment(this.environment))
+                        return;
+                    const { magicString, getMagicStringResult } = getMagicString(code, id);
+                    magicString.replaceAll(DYNAMIC_IMPORT, 'import');
+                    return getMagicStringResult();
+                },
+            },
+        },
+    ];
+}

package/dist/esm/node/vite/plugins/{pluginNonRunnableDev.d.ts → non-runnable-dev/pluginViteRPC.d.ts}

@@ -1,6 +1,6 @@
-export { pluginNonRunnableDev };
+export { pluginViteRPC };
 import type { Plugin, ViteDevServer } from 'vite';
-import type { ClientDependency } from '../../../shared/getPageFiles/analyzePageClientSide/ClientDependency.js';
+import type { ClientDependency } from '../../../../shared/getPageFiles/analyzePageClientSide/ClientDependency.js';
 export type ViteRPC = ReturnType<typeof getViteRpcFunctions>;
 declare function getViteRpcFunctions(viteDevServer: ViteDevServer): {
     transformIndexHtmlRPC(html: string): Promise<string>;
@@ -19,8 +19,4 @@ declare function getViteRpcFunctions(viteDevServer: ViteDevServer): {
         };
     }>;
 };
-declare global {
-    var __VIKE__DYNAMIC_IMPORT: (module: string) => Promise<Record<string, unknown>>;
-    var __VIKE__IS_NON_RUNNABLE_DEV: undefined | boolean;
-}
-declare function pluginNonRunnableDev(): Plugin[];
+declare function pluginViteRPC(): Plugin[];

package/dist/esm/node/vite/plugins/non-runnable-dev/pluginViteRPC.js

@@ -0,0 +1,30 @@
+export { pluginViteRPC };
+import { createViteRPC, isDevCheck } from '../../utils.js';
+import { retrievePageAssetsDev } from '../../../runtime/renderPage/getPageAssets/retrievePageAssetsDev.js';
+import { getViteConfigRuntime } from '../../shared/getViteConfigRuntime.js';
+function getViteRpcFunctions(viteDevServer) {
+    return {
+        async transformIndexHtmlRPC(html) {
+            return await viteDevServer.transformIndexHtml('/', html);
+        },
+        async retrievePageAssetsDevRPC(clientDependencies, clientEntries) {
+            return await retrievePageAssetsDev(viteDevServer, clientDependencies, clientEntries);
+        },
+        async getViteConfigRuntimeRPC() {
+            return getViteConfigRuntime(viteDevServer.config);
+        },
+    };
+}
+function pluginViteRPC() {
+    return [
+        {
+            name: 'vike:pluginViteRPC:1',
+            apply: (_, configEnv) => isDevCheck(configEnv),
+            configureServer: {
+                handler(viteDevServer) {
+                    createViteRPC(viteDevServer, getViteRpcFunctions);
+                },
+            },
+        },
+    ];
+}

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

@@ -1,6 +1,6 @@
 export { pluginCommon };
 import { assert, assertUsage, assertWarning, hasProp, isDevCheck, isDocker, isObject, isVitest } from '../utils.js';
-import { assertRollupInput } from './pluginBuild/pluginBuildConfig.js';
+import { assertRollupInput } from './build/pluginBuildConfig.js';
 import { installRequireShim_setUserRootDir } from '@brillout/require-shim';
 import pc from '@brillout/picocolors';
 import { assertResolveAlias } from './pluginCommon/assertResolveAlias.js';
@@ -129,9 +129,6 @@ function assertVikeCliOrApi(config) {
         return;
     if (isViteCliCall()) {
         assert(!isVitest());
-        assertWarning(false, `Vite's CLI is deprecated ${pc.underline('https://vike.dev/migration/cli')}`, {
-            onlyOnce: true,
-        });
         return;
     }
     if (isVitest()) {
@@ -144,9 +141,6 @@ function assertVikeCliOrApi(config) {
         });
         return;
     }
-    assertWarning(false, `Vite's JavaScript API is deprecated ${pc.underline('https://vike.dev/migration/cli#api')}`, {
-        onlyOnce: true,
-    });
 }
 // TO-DO/next-major-release: remove https://github.com/vikejs/vike/issues/2122
 function temp_supportOldInterface(config) {

package/dist/esm/node/vite/plugins/pluginDev/determineOptimizeDeps.js

@@ -2,7 +2,7 @@ export { determineOptimizeDeps };
 import { findPageFiles } from '../../shared/findPageFiles.js';
 import { assert, assertIsImportPathNpmPackage, createDebugger, getNpmPackageName, isArray, isFilePathAbsoluteFilesystem, isVirtualFileId, } from '../../utils.js';
 import { getVikeConfigInternal } from '../../shared/resolveVikeConfigInternal.js';
-import { analyzeClientEntries } from '../pluginBuild/pluginBuildConfig.js';
+import { analyzeClientEntries } from '../build/pluginBuildConfig.js';
 import { virtualFileIdGlobalEntryClientCR, virtualFileIdGlobalEntryClientSR } from '../../../shared/virtualFileId.js';
 import { getFilePathResolved } from '../../shared/getFilePath.js';
 import { getConfigValueSourcesRelevant } from '../pluginVirtualFiles/getConfigValueSourcesRelevant.js';

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

@@ -12,7 +12,7 @@ import { extractAssetsAddQuery } from '../../shared/extractAssetsQuery.js';
 import { isAsset } from '../shared/isAsset.js';
 import { getImportStatements } from '../shared/parseEsModule.js';
 import pc from '@brillout/picocolors';
-import { handleAssetsManifest_isFixEnabled } from './pluginBuild/handleAssetsManifest.js';
+import { handleAssetsManifest_isFixEnabled } from './build/handleAssetsManifest.js';
 import { getVikeConfigInternal } from '../shared/resolveVikeConfigInternal.js';
 import { assertV1Design } from '../../shared/assertV1Design.js';
 import { normalizeId } from '../shared/normalizeId.js';

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

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

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

@@ -0,0 +1,127 @@
+export { pluginReplaceConstantsEnvVars };
+import { loadEnv } from 'vite';
+import { assert, assertPosixPath, assertUsage, assertWarning, escapeRegex, isArray, isNotNullish, lowerFirst, } from '../utils.js';
+import { getModuleFilePathAbsolute } from '../shared/getFilePath.js';
+import { normalizeId } from '../shared/normalizeId.js';
+import { isViteServerSide_extraSafe } from '../shared/isViteServerSide.js';
+import { getMagicString } from '../shared/getMagicString.js';
+const PUBLIC_ENV_PREFIX = 'PUBLIC_ENV__';
+const PUBLIC_ENV_ALLOWLIST = [
+    // https://github.com/vikejs/vike/issues/1724
+    'STORYBOOK',
+];
+// TO-DO/eventually:
+// - Make import.meta.env work inside +config.js
+//   - For it to work, we'll probably need the user to define the settings (e.g. `envDir`) for loadEnv() inside vike.config.js instead of vite.config.js
+//   - Or stop using Vite's `mode` implementation and have Vike implement its own `mode` feature? (So that the only dependencies are `$ vike build --mode staging` and `$ MODE=staging vike build`.)
+const skipNodeModules = '/node_modules/';
+const skipIrrelevant = 'import.meta.env.';
+const filterRolldown = {
+    id: {
+        exclude: `**${skipNodeModules}**`,
+    },
+    code: {
+        include: skipIrrelevant,
+    },
+};
+const filterFunction = (id, code) => {
+    if (id.includes(skipNodeModules))
+        return false;
+    if (!code.includes(skipIrrelevant))
+        return false;
+    return true;
+};
+function pluginReplaceConstantsEnvVars() {
+    let envVarsAll;
+    let envPrefix;
+    let config;
+    return [
+        {
+            name: 'vike:pluginReplaceConstantsEnvVars',
+            enforce: 'post',
+            configResolved: {
+                handler(config_) {
+                    config = config_;
+                    envVarsAll = loadEnv(config.mode, config.envDir || config.root, '');
+                    envPrefix = getEnvPrefix(config);
+                    config.plugins.sort(lowerFirst((plugin) => (plugin.name === 'vite:define' ? 1 : 0)));
+                },
+            },
+            transform: {
+                filter: filterRolldown,
+                handler(code, id, options) {
+                    id = normalizeId(id);
+                    assertPosixPath(id);
+                    assertPosixPath(config.root);
+                    if (!id.startsWith(config.root))
+                        return; // skip linked dependencies
+                    assert(filterFunction(id, code));
+                    const isBuild = config.command === 'build';
+                    const isClientSide = !isViteServerSide_extraSafe(config, this.environment, options);
+                    const { magicString, getMagicStringResult } = getMagicString(code, id);
+                    // Get regex operations
+                    const replacements = Object.entries(envVarsAll)
+                        // Skip env vars that start with [`config.envPrefix`](https://vite.dev/config/shared-options.html#envprefix) => they are already handled by Vite
+                        .filter(([envName]) => !envPrefix.some((prefix) => envName.startsWith(prefix)))
+                        .map(([envName, envVal]) => {
+                        const envStatement = `import.meta.env.${envName}`;
+                        const envStatementRegExpStr = escapeRegex(envStatement) + '\\b';
+                        // Show error (warning in dev) if client code contains a private environment variable (one that doesn't start with PUBLIC_ENV__ and that isn't included in `PUBLIC_ENV_ALLOWLIST`).
+                        if (isClientSide) {
+                            const skip = assertNoClientSideLeak({
+                                envName,
+                                envStatement,
+                                envStatementRegExpStr,
+                                code,
+                                id,
+                                config,
+                                isBuild,
+                            });
+                            if (skip)
+                                return null;
+                        }
+                        return { regExpStr: envStatementRegExpStr, replacement: envVal };
+                    })
+                        .filter(isNotNullish);
+                    // Apply regex operations
+                    replacements.forEach(({ regExpStr, replacement }) => {
+                        magicString.replaceAll(new RegExp(regExpStr, 'g'), JSON.stringify(replacement));
+                    });
+                    return getMagicStringResult();
+                },
+            },
+        },
+    ];
+}
+function getEnvPrefix(config) {
+    const { envPrefix } = config;
+    if (!envPrefix)
+        return [];
+    if (!isArray(envPrefix))
+        return [envPrefix];
+    return envPrefix;
+}
+function assertNoClientSideLeak({ envName, envStatement, envStatementRegExpStr, code, id, config, isBuild, }) {
+    const isPrivate = !envName.startsWith(PUBLIC_ENV_PREFIX) && !PUBLIC_ENV_ALLOWLIST.includes(envName);
+    // ✅ All good
+    if (!isPrivate)
+        return;
+    if (!new RegExp(envStatementRegExpStr).test(code))
+        return true;
+    // ❌ Security leak!
+    // - Warning in dev
+    // - assertUsage() and abort when building for production
+    const modulePath = getModuleFilePathAbsolute(id, config);
+    const errMsgAddendum = isBuild ? '' : ' (Vike will prevent your app from building for production)';
+    const envNameFixed = `${PUBLIC_ENV_PREFIX}${envName}`;
+    const errMsg = `${envStatement} is used in client-side file ${modulePath} which means that the environment variable ${envName} will be included in client-side bundles and, therefore, ${envName} will be publicly exposed which can be a security leak${errMsgAddendum}. Use ${envStatement} only in server-side files, or rename ${envName} to ${envNameFixed}, see https://vike.dev/env`;
+    if (isBuild) {
+        assertUsage(false, errMsg);
+    }
+    else {
+        // - Only a warning for faster development DX (e.g. when user toggles `ssr: boolean` or `onBeforeRenderIsomorph: boolean`).
+        // - Although only showing a warning can be confusing: https://github.com/vikejs/vike/issues/1641
+        assertWarning(false, errMsg, { onlyOnce: true });
+    }
+    assert(!isBuild); // we should abort if building for production
+}

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

@@ -0,0 +1,17 @@
+export { pluginReplaceConstantsGlobalThis };
+import type { Plugin } from 'vite';
+declare global {
+    /** Like `import.meta.env.DEV` but works inside `node_modules/` (even if package is `ssr.external`). The value `undefined` is to be interpreted as `false`. */
+    var __VIKE__IS_DEV: boolean | undefined;
+    /** Like `import.meta.env.SSR` but works inside `node_modules/` (even if package is `ssr.external`). The value `undefined` is to be interpreted as `false`. */
+    var __VIKE__IS_CLIENT: boolean | undefined;
+    /**
+     * Whether a debug flag is enabled (either the global flag `DEBUG=vike` or a specific flag `DEBUG=vike:some-flag`).
+     *
+     * WARNING: must be used ONLY on the client-side. (The value is always `undefined` on the server-side.)
+     *
+     * In isomorhpic code, use `globalThis.__VIKE__IS_CLIENT` to make sure it's only used on the client-side.
+     */
+    var __VIKE__IS_DEBUG: boolean | undefined;
+}
+declare function pluginReplaceConstantsGlobalThis(): Plugin[];

package/dist/esm/node/vite/plugins/{pluginReplaceGlobalThisConstants.js → pluginReplaceConstantsGlobalThis.js}

@@ -1,5 +1,5 @@
-export { pluginReplaceGlobalThisConstants };
-import { assert } from '../utils.js';
+export { pluginReplaceConstantsGlobalThis };
+import { assert, isDebug } from '../utils.js';
 // === Explanation: globalThis.__VIKE__IS_DEV
 // If client-side => always noExternal => globalThis.__VIKE__IS_DEV is set by the `define` config below.
 // If server-side:
@@ -13,10 +13,10 @@ import { assert } from '../utils.js';
 // If client-side => always noExternal => globalThis.__VIKE__IS_CLIENT is set to `true` by the `define` config below.
 // If server-side => globalThis.__VIKE__IS_CLIENT is either `false` or `undefined` (the value `undefined` is to be interpreted as `false`).
 globalThis.__VIKE__IS_CLIENT = false;
-function pluginReplaceGlobalThisConstants() {
+function pluginReplaceConstantsGlobalThis() {
     return [
         {
-            name: 'vike:pluginReplaceGlobalThisConstants',
+            name: 'vike:pluginReplaceConstantsGlobalThis',
             config: {
                 handler(config) {
                     const isDev = config._isDev;
@@ -33,9 +33,16 @@ function pluginReplaceGlobalThisConstants() {
                 handler(name, config) {
                     const consumer = config.consumer ?? (name === 'client' ? 'client' : 'server');
                     const isClientSide = consumer === 'client';
+                    const defineIsDebug = !isClientSide
+                        ? {}
+                        : {
+                            // We purposely only define it on the client-side, because we cannot know the value in server-side ssr.external production.
+                            'globalThis.__VIKE__IS_DEBUG': JSON.stringify(isDebug()),
+                        };
                     return {
                         define: {
                             'globalThis.__VIKE__IS_CLIENT': JSON.stringify(isClientSide),
+                            ...defineIsDebug,
                         },
                     };
                 },

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

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

package/dist/esm/node/vite/plugins/{pluginReplaceIsClientSide.js → pluginReplaceConstantsPageContext.js}

@@ -1,4 +1,4 @@
-export { pluginReplaceIsClientSide };
+export { pluginReplaceConstantsPageContext };
 import { assert, assertPosixPath } from '../utils.js';
 import { normalizeId } from '../shared/normalizeId.js';
 import { isViteServerSide_extraSafe } from '../shared/isViteServerSide.js';
@@ -9,6 +9,8 @@ const constantsIsClientSide = [
     'globalContext.isClientSide',
     'pageContext.globalContext.isClientSide',
 ];
+// - See https://vike.dev/pageContext#narrowing-down
+// - We cannot use [`define`](https://vite.dev/config/shared-options.html#define) because of https://github.com/rolldown/rolldown/issues/4300
 const skipNodeModules = '/node_modules/';
 const skipIrrelevant = 'Context.isClientSide';
 assert(constantsIsClientSide.every((constant) => constant.endsWith(skipIrrelevant)));
@@ -27,11 +29,11 @@ const filterFunction = (id, code) => {
         return false;
     return true;
 };
-function pluginReplaceIsClientSide() {
+function pluginReplaceConstantsPageContext() {
     let config;
     return [
         {
-            name: 'vike:pluginReplaceIsClientSide',
+            name: 'vike:pluginReplaceConstantsPageContext',
             enforce: 'post',
             apply: 'build',
             configResolved: {
@@ -61,8 +63,6 @@ function pluginReplaceIsClientSide() {
                         const regExp = getConstantRegExp(constantsIsClientSide);
                         magicString.replaceAll(regExp, JSON.stringify(replacement));
                     }
-                    if (!magicString.hasChanged())
-                        return null;
                     return getMagicStringResult();
                 },
             },

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

@@ -5,7 +5,7 @@ import { getVikeConfigInternal } from '../../shared/resolveVikeConfigInternal.js
 import { extractAssetsAddQuery } from '../../../shared/extractAssetsQuery.js';
 import { debug } from './debug.js';
 import { serializeConfigValues } from '../../../../shared/page-configs/serialize/serializeConfigValues.js';
-import { handleAssetsManifest_isFixEnabled } from '../pluginBuild/handleAssetsManifest.js';
+import { handleAssetsManifest_isFixEnabled } from '../build/handleAssetsManifest.js';
 import { getConfigValueBuildTime } from '../../../../shared/page-configs/getConfigValueBuildTime.js';
 import { resolveIncludeAssetsImportedByServer } from '../../../runtime/renderPage/getPageAssets/retrievePageAssetsProd.js';
 async function generateVirtualFilePageEntry(id, isDev) {

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,9 +4,8 @@ import MagicString from 'magic-string';
 function getMagicString(code, id) {
     const magicString = new MagicString(code);
     const getMagicStringResult = () => {
-        /* TODO/now uncomment + dedupe
-        if (!magicString.hasChanged()) return undefined
-        */
+        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/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

@@ -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/utils/PROJECT_VERSION.d.ts

@@ -1 +1 @@
-export declare const PROJECT_VERSION: "0.4.239-commit-95ab407";
+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-commit-95ab407';
+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;

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',
@@ -40,7 +43,6 @@ if (isDebug())
     Error.stackTraceLimit = Infinity;
 assertFlagsActivated();
 function createDebugger(flag, optionsGlobal) {
-    checkType(flag);
     assert(flags.includes(flag));
     const debugWithOptions = (optionsLocal) => {
         return (...msgs) => {
@@ -52,6 +54,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,7 +85,6 @@ 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));
@@ -152,17 +156,30 @@ function assertFlagsActivated() {
         assertUsage(flags.includes(flag), `Unknown DEBUG flag ${pc.cyan(flag)}. Valid flags:\n${flags.map((f) => `  ${pc.cyan(f)}`).join('\n')}`);
     });
 }
+// TODO/now: refactor isAll
+// TODO/now: refactor inline flagRegex
 function getFlagsActivated() {
     const flagsActivated = DEBUG.match(flagRegex) ?? [];
     const all = DEBUG.includes('vike:*');
-    return { flagsActivated, all };
+    const isGlobal = /\bvike\b[^:]/.test(DEBUG);
+    return { flagsActivated, all, isGlobal };
 }
 function isDebug() {
-    const { flagsActivated, all } = getFlagsActivated();
-    return all || flagsActivated.length > 0;
+    const { flagsActivated, all, isGlobal } = getFlagsActivated();
+    return all || flagsActivated.length > 0 || isGlobal;
 }
 function getDEBUG() {
     let DEBUG;
+    // ssr.noExternal
+    /* // Full implementation:
+       // - https://github.com/vikejs/vike/commit/7637564a98f43e23834bcae2f7ada8d941958a34
+       // - https://github.com/vikejs/vike/pull/2718
+       // - We don't implement this yet because it crashes @cloudflare/vite-plugin
+    if (import.meta.env) {
+      return import.meta.env.DEBUG
+    }
+    //*/
+    // ssr.external
     // - `process` can be undefined in edge workers
     // - We want bundlers to be able to statically replace `process.env.*`
     try {

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/isDev.js

@@ -5,8 +5,10 @@ import { assertUsage } from './assert.js';
 function isDevCheck(configEnv) {
     const { isPreview, command } = configEnv;
     // Note that:
-    // - `assertVersion('Vite', version, '5.1.0')` at node/vite/onLoad.ts isn't enough: https://github.com/vitejs/vite/pull/19355
+    // - `assertVersion('Vite', version, '5.1.0')` isn't enough: https://github.com/vitejs/vite/pull/19355
     // - We'll eventually be able to make this an assert() instead of assertUsage() once Vike requires a Vite version that supports this.meta.viteVersion
+    //   - https://github.com/vitejs/vite/pull/20088
+    //   - Released at 7.0.0: https://github.com/vitejs/vite/blob/main/packages/vite/CHANGELOG.md#700-2025-06-24
     assertUsage(typeof isPreview === 'boolean', 'You are using an old Vite version; make sure to use Vite 5.1.0 or above.');
     return command === 'serve' && !isPreview;
 }

package/dist/esm/utils/isNonRunnableDev.js

@@ -3,8 +3,8 @@ import { assert } from './assert.js';
 import { assertIsNotBrowser } from './assertIsNotBrowser.js';
 assertIsNotBrowser();
 function isNonRunnableDev() {
-    if (typeof __VIKE__IS_NON_RUNNABLE_DEV === 'undefined')
+    if (globalThis.__VIKE__IS_NON_RUNNABLE_DEV === undefined)
         return false;
-    assert(__VIKE__IS_NON_RUNNABLE_DEV === true);
+    assert(globalThis.__VIKE__IS_NON_RUNNABLE_DEV === true);
     return true;
 }

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()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.239-commit-95ab407",
+  "version": "0.4.240-commit-bac5dee",
   "repository": "https://github.com/vikejs/vike",
   "exports": {
     "./server": {
@@ -114,7 +114,7 @@
   },
   "dependencies": {
     "@brillout/import": "^0.2.6",
-    "@brillout/json-serializer": "^0.5.20",
+    "@brillout/json-serializer": "^0.5.21",
     "@brillout/picocolors": "^1.0.26",
     "@brillout/require-shim": "^0.1.2",
     "@brillout/vite-plugin-server-entry": "^0.7.15",

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

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

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

@@ -1,112 +0,0 @@
-export { pluginEnvVars };
-import { loadEnv } from 'vite';
-import { assert, assertPosixPath, assertUsage, assertWarning, escapeRegex, isArray, isNotNullish, lowerFirst, } from '../utils.js';
-import { getModuleFilePathAbsolute } from '../shared/getFilePath.js';
-import { normalizeId } from '../shared/normalizeId.js';
-import { isViteServerSide_extraSafe } from '../shared/isViteServerSide.js';
-import { getMagicString } from '../shared/getMagicString.js';
-// TO-DO/eventually:
-// - Make import.meta.env work inside +config.js
-//   - For it to work, we'll probably need the user to define the settings (e.g. `envDir`) for loadEnv() inside vike.config.js instead of vite.config.js
-//   - Or stop using Vite's `mode` implementation and have Vike implement its own `mode` feature? (So that the only dependencies are `$ vike build --mode staging` and `$ MODE=staging vike build`.)
-const PUBLIC_ENV_PREFIX = 'PUBLIC_ENV__';
-const PUBLIC_ENV_ALLOWLIST = [
-    // https://github.com/vikejs/vike/issues/1724
-    'STORYBOOK',
-];
-const skipNodeModules = '/node_modules/';
-const skipIrrelevant = 'import.meta.env.';
-const filterRolldown = {
-    id: {
-        exclude: `**${skipNodeModules}**`,
-    },
-    code: {
-        include: skipIrrelevant,
-    },
-};
-const filterFunction = (id, code) => {
-    if (id.includes(skipNodeModules))
-        return false;
-    if (!code.includes(skipIrrelevant))
-        return false;
-    return true;
-};
-function pluginEnvVars() {
-    let envsAll;
-    let config;
-    return [
-        {
-            name: 'vike:pluginEnvVars',
-            enforce: 'post',
-            configResolved: {
-                handler(config_) {
-                    config = config_;
-                    envsAll = loadEnv(config.mode, config.envDir || config.root, '');
-                    config.plugins.sort(lowerFirst((plugin) => (plugin.name === 'vite:define' ? 1 : 0)));
-                },
-            },
-            transform: {
-                filter: filterRolldown,
-                handler(code, id, options) {
-                    id = normalizeId(id);
-                    assertPosixPath(id);
-                    assertPosixPath(config.root);
-                    if (!id.startsWith(config.root))
-                        return; // skip linked dependencies
-                    assert(filterFunction(id, code));
-                    const isBuild = config.command === 'build';
-                    const isClientSide = !isViteServerSide_extraSafe(config, this.environment, options);
-                    const { magicString, getMagicStringResult } = getMagicString(code, id);
-                    // Find & check
-                    const replacements = Object.entries(envsAll)
-                        .filter(([key]) => {
-                        // Already handled by Vite
-                        const envPrefix = !config.envPrefix
-                            ? []
-                            : isArray(config.envPrefix)
-                                ? config.envPrefix
-                                : [config.envPrefix];
-                        return !envPrefix.some((prefix) => key.startsWith(prefix));
-                    })
-                        .map(([envName, envVal]) => {
-                        const envStatement = `import.meta.env.${envName}`;
-                        const envStatementRegExpStr = escapeRegex(envStatement) + '\\b';
-                        // Security check
-                        {
-                            const isPrivate = !envName.startsWith(PUBLIC_ENV_PREFIX) && !PUBLIC_ENV_ALLOWLIST.includes(envName);
-                            if (isPrivate && isClientSide) {
-                                if (!new RegExp(envStatementRegExpStr).test(code))
-                                    return;
-                                const modulePath = getModuleFilePathAbsolute(id, config);
-                                const errMsgAddendum = isBuild
-                                    ? ''
-                                    : ' (Vike will prevent your app from building for production)';
-                                const keyPublic = `${PUBLIC_ENV_PREFIX}${envName}`;
-                                const errMsg = `${envStatement} is used in client-side file ${modulePath} which means that the environment variable ${envName} will be included in client-side bundles and, therefore, ${envName} will be publicly exposed which can be a security leak${errMsgAddendum}. Use ${envStatement} only in server-side files, or rename ${envName} to ${keyPublic}, see https://vike.dev/env`;
-                                if (isBuild) {
-                                    assertUsage(false, errMsg);
-                                }
-                                else {
-                                    // - Only a warning for faster development DX (e.g. when user toggles `ssr: boolean` or `onBeforeRenderIsomorph: boolean`).
-                                    // - But only showing a warning can be confusing: https://github.com/vikejs/vike/issues/1641
-                                    assertWarning(false, errMsg, { onlyOnce: true });
-                                }
-                            }
-                            // Double check
-                            assert(!(isPrivate && isClientSide) || !isBuild);
-                        }
-                        return { regExpStr: envStatementRegExpStr, replacement: envVal };
-                    })
-                        .filter(isNotNullish);
-                    // Apply
-                    replacements.forEach(({ regExpStr, replacement }) => {
-                        magicString.replaceAll(new RegExp(regExpStr, 'g'), JSON.stringify(replacement));
-                    });
-                    if (!magicString.hasChanged())
-                        return null;
-                    return getMagicStringResult();
-                },
-            },
-        },
-    ];
-}

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

@@ -1,86 +0,0 @@
-export { pluginNonRunnableDev };
-import { createViteRPC, assertIsNotProductionRuntime, isRunnableDevEnvironment, assert, isDevCheck } from '../utils.js';
-import { retrievePageAssetsDev } from '../../runtime/renderPage/getPageAssets/retrievePageAssetsDev.js';
-import { getViteConfigRuntime } from '../shared/getViteConfigRuntime.js';
-import { getMagicString } from '../shared/getMagicString.js';
-// TODO/now: move to vite/index.ts
-assertIsNotProductionRuntime();
-/* We cannot use [`filter.id`](https://rolldown.rs/plugins/hook-filters) because Vite's optimizeDeps bundles the package `vike` into node_modules/.vite/deps_ssr/chunk-WBC5FHD7.js
-const distFileIsNonRunnableDev = requireResolveDistFile('dist/esm/utils/isNonRunnableDev.js')
-const distFileGlobalContext = requireResolveDistFile('dist/esm/node/runtime/globalContext.js')
-const filterRolldown = {
-  id: {
-    include: [distFileIsNonRunnableDev, distFileGlobalContext].map(
-      (filePath) => new RegExp(`^${escapeRegex(filePath)}($|${escapeRegex('?')}.*)`),
-    ),
-  },
-}
-*/
-const __VIKE__DYNAMIC_IMPORT = '__VIKE__DYNAMIC_IMPORT';
-const __VIKE__IS_NON_RUNNABLE_DEV = '__VIKE__IS_NON_RUNNABLE_DEV';
-function getViteRpcFunctions(viteDevServer) {
-    return {
-        async transformIndexHtmlRPC(html) {
-            return await viteDevServer.transformIndexHtml('/', html);
-        },
-        async retrievePageAssetsDevRPC(clientDependencies, clientEntries) {
-            return await retrievePageAssetsDev(viteDevServer, clientDependencies, clientEntries);
-        },
-        async getViteConfigRuntimeRPC() {
-            return getViteConfigRuntime(viteDevServer.config);
-        },
-    };
-}
-function pluginNonRunnableDev() {
-    let config;
-    return [
-        {
-            name: 'vike:pluginNonRunnableDev:1',
-            apply: (_, configEnv) => isDevCheck(configEnv),
-            configureServer: {
-                handler(viteDevServer) {
-                    createViteRPC(viteDevServer, getViteRpcFunctions);
-                },
-            },
-            configResolved: {
-                handler(config_) {
-                    config = config_;
-                },
-            },
-            transform: {
-                filter: {
-                    code: {
-                        include: __VIKE__IS_NON_RUNNABLE_DEV,
-                    },
-                },
-                handler(code, id) {
-                    assert(config._isDev);
-                    if (isRunnableDevEnvironment(this.environment))
-                        return;
-                    const { magicString, getMagicStringResult } = getMagicString(code, id);
-                    magicString.replaceAll(__VIKE__IS_NON_RUNNABLE_DEV, JSON.stringify(true));
-                    return getMagicStringResult();
-                },
-            },
-        },
-        {
-            name: 'vike:pluginNonRunnableDev:2',
-            apply: (_, configEnv) => isDevCheck(configEnv),
-            transform: {
-                filter: {
-                    code: {
-                        include: __VIKE__DYNAMIC_IMPORT,
-                    },
-                },
-                handler(code, id) {
-                    assert(config._isDev);
-                    if (isRunnableDevEnvironment(this.environment))
-                        return;
-                    const { magicString, getMagicStringResult } = getMagicString(code, id);
-                    magicString.replaceAll(__VIKE__DYNAMIC_IMPORT, 'import');
-                    return getMagicStringResult();
-                },
-            },
-        },
-    ];
-}

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

@@ -1,9 +0,0 @@
-export { pluginReplaceGlobalThisConstants };
-import type { Plugin } from 'vite';
-declare global {
-    /** Like `import.meta.env.DEV` but works inside `node_modules/` (even if package is `ssr.external`). The value `undefined` is to be interpreted as `false`. */
-    var __VIKE__IS_DEV: boolean | undefined;
-    /** Like `import.meta.env.SSR` but works inside `node_modules/` (even if package is `ssr.external`). The value `undefined` is to be interpreted as `false`. */
-    var __VIKE__IS_CLIENT: boolean | undefined;
-}
-declare function pluginReplaceGlobalThisConstants(): Plugin[];

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

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

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

@@ -1,6 +0,0 @@
-export { debug };
-export { setCreateDebugger };
-import type { createDebugger, Debug } from '../../utils/debug.js';
-type CreateDebugger = typeof createDebugger;
-declare function debug(...args: Parameters<Debug>): void;
-declare function setCreateDebugger(createDebugger: CreateDebugger): void;

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

@@ -1,21 +0,0 @@
-export { debug };
-export { setCreateDebugger };
-// Using createDebugger() for isomorphic code without bloating the client-side.
-// On the server-side, this is just a transparent proxy.
-// On the client-side, this is an empty shell.
-import { getGlobalObject } from '../../utils/getGlobalObject.js';
-const globalObject = getGlobalObject('route/debug.ts', {});
-function debug(...args) {
-    // Client-side => does nothing
-    if (!globalObject.createDebugger)
-        return;
-    // Server-side => just a proxy
-    if (!globalObject.debug) {
-        globalObject.debug = globalObject.createDebugger('vike:routing');
-    }
-    globalObject.debug(...args);
-}
-// Called only on the server-side
-function setCreateDebugger(createDebugger) {
-    globalObject.createDebugger = createDebugger;
-}