vike 0.4.247-commit-87e5f2f → 0.4.247-commit-1250e38

package/dist/client/runtime-client-routing/getPageContext.js

@@ -2,6 +2,7 @@ export { getPageContext };
 export { providePageContext };
 // TO-DO/eventually: create new setting `+asyncHook: true` that sets the default value of the `asyncHook` parameter below to `true`
 // TODO/next-release: update vike-{react,vue,solid} usage
+// TODO/next-release: contact Da-Jin about `window.history.state?.vike` https://vike.dev/navigate#history-pushstate
 import { getPageContext_sync, providePageContext } from '../../shared-server-client/hooks/execHook.js';
 import { getPageContextClient } from './renderPageClient.js';
 function getPageContext({ asyncHook } = {}) {

package/dist/node/api/dev.js

@@ -3,9 +3,10 @@ export { dev };
 export { startupLog };
 import { prepareViteApiCall } from './prepareViteApiCall.js';
 import { createServer } from 'vite';
-import { assert, colorVike, colorVite, PROJECT_VERSION } from './utils.js';
+import { assert, assertIsNotProductionRuntime, colorVike, colorVite, PROJECT_VERSION } from './utils.js';
 import pc from '@brillout/picocolors';
 import { processStartupLog } from '../vite/shared/loggerVite.js';
+assertIsNotProductionRuntime();
 /**
  * Programmatically trigger `$ vike dev`
  *

package/dist/node/vite/index.js

@@ -17,7 +17,7 @@ import { pluginSetGlobalContext } from './plugins/pluginSetGlobalContext.js';
 import { pluginCommon } from './plugins/pluginCommon.js';
 import { pluginBaseUrls } from './plugins/pluginBaseUrls.js';
 import { pluginReplaceConstantsEnvVars } from './plugins/pluginReplaceConstantsEnvVars.js';
-import { pluginFileEnv } from './plugins/pluginFileEnv.js';
+import { pluginAssertFileEnv } from './plugins/pluginAssertFileEnv.js';
 import { pluginWorkaroundCssModuleHmr } from './plugins/pluginWorkaroundCssModuleHmr.js';
 import { pluginWorkaroundVite6HmrRegression } from './plugins/pluginWorkaroundVite6HmrRegression.js';
 import { pluginReplaceConstantsPageContext } from './plugins/pluginReplaceConstantsPageContext.js';
@@ -53,7 +53,7 @@ function plugin(vikeVitePluginOptions = {}) {
             ...pluginSetGlobalContext(),
             ...pluginBaseUrls(),
             ...pluginReplaceConstantsEnvVars(),
-            ...pluginFileEnv(),
+            ...pluginAssertFileEnv(),
             ...pluginWorkaroundCssModuleHmr(),
             ...pluginWorkaroundVite6HmrRegression(),
             ...pluginReplaceConstantsPageContext(),

package/dist/node/vite/plugins/pluginAssertFileEnv.d.ts

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

package/dist/node/vite/plugins/{pluginFileEnv.js → pluginAssertFileEnv.js}

@@ -1,4 +1,4 @@
-export { pluginFileEnv };
+export { pluginAssertFileEnv };
 import { assert, assertUsage, assertWarning, capitalizeFirstLetter, isFilePathAbsolute, joinEnglish, rollupSourceMapRemove, } from '../utils.js';
 import { extractAssetsRE } from './pluginExtractAssets.js';
 import { extractExportNamesRE } from './pluginExtractExportNames.js';
@@ -8,26 +8,26 @@ import { getExportNames } from '../shared/parseEsModule.js';
 import { normalizeId } from '../shared/normalizeId.js';
 import { isV1Design } from '../shared/resolveVikeConfigInternal.js';
 import { isViteServerSide, isViteServerSide_extraSafe } from '../shared/isViteServerSide.js';
-const skipNodeModules = '/node_modules/'; // Only apply `.server.js` and `.client.js` to user files
+import { suffixesAssertFileEnv } from '../../../shared-server-node/getFileSuffixes.js';
+const envS = suffixesAssertFileEnv;
+const skipNodeModules = '/node_modules/'; // Only assert `.server.js`, `.client.js` and `.ssr.js` for user files
 const filterRolldown = {
     id: {
-        include: ['client', 'server'].map((env) => `**/*${getSuffix(env)}*`),
+        include: envS.map((env) => `**/*${getSuffix(env)}*`),
         exclude: [`**${skipNodeModules}**`],
     },
 };
 const filterFunction = (id) => {
     if (id.includes(skipNodeModules))
         return false;
-    if (!id.includes(getSuffix('client')) && !id.includes(getSuffix('server')))
-        return false;
-    return true;
+    return envS.some((suffix) => id.includes(getSuffix(suffix)));
 };
-function pluginFileEnv() {
+function pluginAssertFileEnv() {
     let config;
     let viteDevServer;
     return [
         {
-            name: 'vike:pluginFileEnv',
+            name: 'vike:pluginAssertFileEnv',
             load: {
                 filter: filterRolldown,
                 handler(id, options) {
@@ -68,7 +68,7 @@ function pluginFileEnv() {
                         return;
                     const { importers } = this.getModuleInfo(id);
                     // Throwing a verbose error doesn't waste client-side KBs as dynamic imports are code split.
-                    const errMsg = getErrorMessage(id, isServerSide, importers, false, true);
+                    const errMsg = getErrMsg(id, isServerSide, importers, false, config, true);
                     // We have to inject empty exports to avoid Rollup complaining about missing exports, see https://gist.github.com/brillout/5ea45776e65bd65100a52ecd7bfda3ff
                     const { exportNames } = await getExportNames(code);
                     return rollupSourceMapRemove([
@@ -111,7 +111,7 @@ function pluginFileEnv() {
     function assertFileEnv(moduleId, isServerSide, importers, onlyWarn) {
         if (!isWrongEnv(moduleId, isServerSide))
             return;
-        const errMsg = getErrorMessage(moduleId, isServerSide, importers, onlyWarn, false);
+        const errMsg = getErrMsg(moduleId, isServerSide, importers, onlyWarn, config, false);
         if (onlyWarn) {
             assertWarning(false, errMsg, { onlyOnce: true });
         }
@@ -119,38 +119,43 @@ function pluginFileEnv() {
             assertUsage(false, errMsg);
         }
     }
-    function getErrorMessage(moduleId, isServerSide, importers, onlyWarn, noColor) {
-        const modulePath = getModulePath(moduleId);
-        const envActual = isServerSide ? 'server' : 'client';
-        const envExpect = isServerSide ? 'client' : 'server';
-        let errMsg;
-        let modulePathPretty = getFilePathToShowToUserModule(modulePath, config);
-        if (!noColor) {
-            const suffix = getSuffix(envExpect);
-            modulePathPretty = modulePathPretty.replaceAll(suffix, pc.bold(suffix));
-        }
-        errMsg = `${capitalizeFirstLetter(envExpect)}-only file ${modulePathPretty} (https://vike.dev/file-env) imported on the ${envActual}-side`;
-        {
-            const importPaths = importers
-                .filter((importer) => 
-            // Can be Vike's virtual module: https://github.com/vikejs/vike/issues/2483
-            isFilePathAbsolute(importer))
-                .map((importer) => getFilePathToShowToUserModule(importer, config))
-                .map((importPath) => pc.cyan(importPath));
-            if (importPaths.length > 0) {
-                errMsg += ` by ${joinEnglish(importPaths, 'and')}`;
-            }
-        }
-        if (onlyWarn) {
-            errMsg += ". This is potentially a security issue and Vike won't allow you to build your app for production.";
-        }
-        return errMsg;
-    }
 }
 function isWrongEnv(moduleId, isServerSide) {
     const modulePath = getModulePath(moduleId);
-    const suffixWrong = getSuffix(isServerSide ? 'client' : 'server');
-    return modulePath.includes(suffixWrong);
+    if (isServerSide) {
+        // On server-side, .client. is wrong
+        return modulePath.includes(getSuffix('client'));
+    }
+    else {
+        // On client-side, both .server. and .ssr. are wrong
+        return modulePath.includes(getSuffix('server')) || modulePath.includes(getSuffix('ssr'));
+    }
+}
+function getErrMsg(moduleId, isServerSide, importers, onlyWarn, config, noColor) {
+    const envActual = isServerSide ? 'server' : 'client';
+    const envExpect = isServerSide ? 'client' : 'server';
+    const modulePath = getModulePath(moduleId);
+    let modulePathPretty = getFilePathToShowToUserModule(modulePath, config);
+    if (!noColor) {
+        const suffix = modulePath.includes(getSuffix('ssr')) ? getSuffix('ssr') : getSuffix(envExpect);
+        modulePathPretty = modulePathPretty.replaceAll(suffix, pc.bold(suffix));
+    }
+    let errMsg = `${capitalizeFirstLetter(envExpect)}-only file ${modulePathPretty} (https://vike.dev/file-env) imported on the ${envActual}-side`;
+    {
+        const importPaths = importers
+            .filter((importer) => 
+        // Can be Vike's virtual module: https://github.com/vikejs/vike/issues/2483
+        isFilePathAbsolute(importer))
+            .map((importer) => getFilePathToShowToUserModule(importer, config))
+            .map((importPath) => pc.cyan(importPath));
+        if (importPaths.length > 0) {
+            errMsg += ` by ${joinEnglish(importPaths, 'and')}`;
+        }
+    }
+    if (onlyWarn) {
+        errMsg += ". This is potentially a security issue and Vike won't allow you to build your app for production.";
+    }
+    return errMsg;
 }
 function skip(id, userRootDir) {
     assert(filterFunction(id));

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

@@ -56,7 +56,7 @@ function assertResolveAlias(config) {
                 assertUsage(find !== '', msg);
             }
             // Ensure path alias are distinguishable from npm package names, which is needed by:
-            //  - determineOptimizeDeps()
+            //  - resolveOptimizeDeps()
             //  - extractAssets
             //  - in general: using un-distinguishable path aliases is asking for trouble
             if (!isPathAliasRecommended(find)) {

package/dist/node/vite/plugins/pluginDev/optimizeDeps.d.ts

@@ -0,0 +1,15 @@
+export { optimizeDeps };
+export { resolveOptimizeDeps };
+import type { ResolvedConfig } from 'vite';
+declare const optimizeDeps: {
+    readonly optimizeDeps: {
+        readonly exclude: ["vike/client", "vike/client/router"];
+        readonly include: ["vike > @brillout/json-serializer/parse", "vike > @brillout/json-serializer/stringify", "vike > @brillout/picocolors"];
+    };
+    readonly ssr: {
+        readonly optimizeDeps: {
+            readonly exclude: ["@brillout/import", "@brillout/json-serializer", "@brillout/picocolors", "@brillout/vite-plugin-server-entry", "vike"];
+        };
+    };
+};
+declare function resolveOptimizeDeps(config: ResolvedConfig): Promise<void>;

package/dist/node/vite/plugins/pluginDev/{determineOptimizeDeps.js → optimizeDeps.js}

@@ -1,4 +1,5 @@
-export { determineOptimizeDeps };
+export { optimizeDeps };
+export { resolveOptimizeDeps };
 import { findPageFiles } from '../../shared/findPageFiles.js';
 import { assert, assertIsImportPathNpmPackage, createDebug, getNpmPackageName, isArray, isFilePathAbsoluteFilesystem, isVirtualFileId, requireResolveOptional, } from '../../utils.js';
 import { getVikeConfigInternal } from '../../shared/resolveVikeConfigInternal.js';
@@ -7,7 +8,8 @@ import { virtualFileIdGlobalEntryClientCR, virtualFileIdGlobalEntryClientSR, } f
 import { getFilePathResolved } from '../../shared/getFilePath.js';
 import { getConfigValueSourcesRelevant } from '../pluginVirtualFiles/getConfigValueSourcesRelevant.js';
 const debug = createDebug('vike:optimizeDeps');
-const WORKAROUND_LATE_DISCOVERY = [
+// Add dependencies that cannot be discovered by Vite during the scanning phase
+const LATE_DISCOVERED = [
     // Workaround for https://github.com/vitejs/vite-plugin-react/issues/650
     // - The issue was closed as completed with https://github.com/vitejs/vite/pull/20495 but it doesn't fix the issue and the workaround is still needed.
     // - TO-DO/eventually: try removing the workaround and see if the CI fails (at test/@cloudflare_vite-plugin/) — maybe the issue will get fixed at some point.
@@ -15,11 +17,47 @@ const WORKAROUND_LATE_DISCOVERY = [
     // Workaround for https://github.com/vikejs/vike/issues/2823#issuecomment-3514325487
     '@compiled/react/runtime',
 ];
-async function determineOptimizeDeps(config) {
+const optimizeDeps = {
+    optimizeDeps: {
+        exclude: [
+            // We must exclude Vike's client runtime so it can import virtual modules
+            'vike/client',
+            'vike/client/router',
+        ],
+        include: [
+            // Avoid:
+            // ```
+            // 9:28:58 AM [vite] ✨ new dependencies optimized: @brillout/json-serializer/parse
+            // 9:28:58 AM [vite] ✨ optimized dependencies changed. reloading
+            // ```
+            'vike > @brillout/json-serializer/parse',
+            'vike > @brillout/json-serializer/stringify',
+            'vike > @brillout/picocolors',
+        ],
+    },
+    ssr: {
+        optimizeDeps: {
+            exclude: [
+                '@brillout/import',
+                '@brillout/json-serializer',
+                '@brillout/picocolors',
+                '@brillout/vite-plugin-server-entry',
+                'vike',
+            ],
+        },
+    },
+};
+// Populate optimizeDeps with dynamic entries:
+// - User's + files (i.e. Vike entries)
+// - Late discovered dependencies (if they exist)
+// - Make server environments inherit from ssr.optimizeDeps (it isn't the case by default)
+async function resolveOptimizeDeps(config) {
     const vikeConfig = await getVikeConfigInternal();
     const { _pageConfigs: pageConfigs } = vikeConfig;
+    // Retrieve user's + files (i.e. Vike entries)
     const { entriesClient, entriesServer, includeClient, includeServer } = await getPageDeps(config, pageConfigs);
-    WORKAROUND_LATE_DISCOVERY.forEach((dep) => {
+    // Add late discovered dependencies, if they exist
+    LATE_DISCOVERED.forEach((dep) => {
         const userRootDir = config.root;
         const resolved = requireResolveOptional({ importPath: dep, userRootDir, importerFilePath: null });
         const resolvedInsideRepo = resolved && resolved.startsWith(userRootDir);
@@ -39,8 +77,10 @@ async function determineOptimizeDeps(config) {
             includeServer.push(dep);
         }
     });
+    // Set optimizeDeps (client-side)
     config.optimizeDeps.include = add(config.optimizeDeps.include, includeClient);
     config.optimizeDeps.entries = add(config.optimizeDeps.entries, entriesClient);
+    // Set optimizeDeps (server-side)
     for (const envName in config.environments) {
         const env = config.environments[envName];
         if (env.consumer === 'server' && env.optimizeDeps.noDiscovery === false) {
@@ -48,6 +88,7 @@ async function determineOptimizeDeps(config) {
             env.optimizeDeps.entries = add(env.optimizeDeps.entries, entriesServer);
         }
     }
+    // Debug
     if (debug.isActivated)
         debug('optimizeDeps', {
             'config.optimizeDeps.entries': config.optimizeDeps.entries,

package/dist/node/vite/plugins/pluginDev.d.ts

@@ -1,5 +1,5 @@
 export { pluginDev };
 export { logDockerHint };
-import type { Plugin, ResolvedConfig } from 'vite';
+import { type Plugin, type ResolvedConfig } from 'vite';
 declare function pluginDev(): Plugin[];
 declare function logDockerHint(configHost: ResolvedConfig['server']['host']): void;

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

@@ -1,6 +1,6 @@
 export { pluginDev };
 export { logDockerHint };
-import { determineOptimizeDeps } from './pluginDev/determineOptimizeDeps.js';
+import { optimizeDeps, resolveOptimizeDeps } from './pluginDev/optimizeDeps.js';
 import { determineFsAllowList } from './pluginDev/determineFsAllowList.js';
 import { addSsrMiddleware } from '../shared/addSsrMiddleware.js';
 import { applyDev, assertWarning, isDocker, isDebugError } from '../utils.js';
@@ -17,30 +17,14 @@ function pluginDev() {
                 handler() {
                     return {
                         appType: 'custom',
-                        optimizeDeps: {
-                            exclude: [
-                                // We must exclude Vike's client runtime so it can import virtual modules
-                                'vike/client',
-                                'vike/client/router',
-                            ],
-                            include: [
-                                // Avoid:
-                                // ```
-                                // 9:28:58 AM [vite] ✨ new dependencies optimized: @brillout/json-serializer/parse
-                                // 9:28:58 AM [vite] ✨ optimized dependencies changed. reloading
-                                // ```
-                                'vike > @brillout/json-serializer/parse',
-                                'vike > @brillout/json-serializer/stringify',
-                                'vike > @brillout/picocolors',
-                            ],
-                        },
+                        ...optimizeDeps,
                     };
                 },
             },
             configResolved: {
                 async handler(config_) {
                     config = config_;
-                    await determineOptimizeDeps(config);
+                    await resolveOptimizeDeps(config);
                     await determineFsAllowList(config);
                     interceptViteLogs(config);
                     logDockerHint(config.server.host);

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

@@ -25,7 +25,7 @@ async function generateVirtualFilePageEntry(id, isDev) {
         assert(pageConfig);
     }
     else {
-        /* This assertion sometimes fail. It happens very seldom and I couldn't reproduce it (https://gist.github.com/brillout/9e212ce829f4d62a912ca163ffa8881a). I suspect some kind of HMR race condition.
+        /* This assertion sometimes fail. It happens very seldom and I couldn't reproduce it (https://gist.github.com/brillout/9e212ce829f4d62a912ca163ffa8881a). I suspect some kind of HMR race condition. UPDATE: [December 2024] This just happened at test/@cloudflare_vite-plugin/ — it isn't blocking, reloading the page fixes the issue.
         assert(pageConfig, { id, pageId })
         /*/
         if (!pageConfig)

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

@@ -3,6 +3,7 @@ export { getConfigValueSourceRelevantAnyEnv };
 export { isRuntimeEnvMatch };
 export { isConfigSourceValueNull };
 import { assert, assertIsNotBrowser } from '../../utils.js';
+import { getFileSuffixes } from '../../../../shared-server-node/getFileSuffixes.js';
 assertIsNotBrowser();
 function getConfigValueSourcesRelevant(configName, runtimeEnv, pageConfig) {
     const configDef = pageConfig.configDefinitions[configName];
@@ -86,10 +87,10 @@ function isConfigSourceValueNull(source) {
 function applyFilenameSuffix(sourcesRelevant) {
     const getFileName = (source) => source.plusFile?.filePath.fileName ?? '';
     // Apply `clear`: truncate at first clear file
-    const clearIndex = sourcesRelevant.findIndex((source) => getFileName(source).includes('.clear.'));
+    const clearIndex = sourcesRelevant.findIndex((source) => getFileSuffixes(getFileName(source)).includes('clear'));
     if (clearIndex !== -1)
         sourcesRelevant = sourcesRelevant.slice(0, clearIndex + 1);
     // Apply `default`: exclude defaults if any non-defaults exist, otherwise keep only first default
-    const nonDefaults = sourcesRelevant.filter((source) => !getFileName(source).includes('.default.'));
+    const nonDefaults = sourcesRelevant.filter((source) => !getFileSuffixes(getFileName(source)).includes('default'));
     return nonDefaults.length > 0 ? nonDefaults : sourcesRelevant.slice(0, 1);
 }

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

@@ -8,10 +8,10 @@ import { reloadVikeConfig, isV1Design, getVikeConfigInternalOptional } from '../
 import pc from '@brillout/picocolors';
 import { logConfigInfo } from '../shared/loggerDev.js';
 import { getFilePathToShowToUserModule } from '../shared/getFilePath.js';
-import { isRunnable, updateUserFiles } from '../../../server/runtime/globalContext.js';
+import { updateUserFiles } from '../../../server/runtime/globalContext.js';
 import { isPlusFile } from '../shared/resolveVikeConfigInternal/crawlPlusFiles.js';
 import { isTemporaryBuildFile } from '../shared/resolveVikeConfigInternal/transpileAndExecuteFile.js';
-import { getVikeConfigError } from '../../../shared-server-node/getVikeConfigError.js';
+import { debugFileChange, getVikeConfigError } from '../../../shared-server-node/getVikeConfigError.js';
 const filterRolldown = {
     id: {
         include: new RegExp(`^(${escapeRegex(virtualFileIdPrefix1)}|${escapeRegex(virtualFileIdPrefix2)})`),
@@ -40,6 +40,7 @@ function pluginVirtualFiles() {
             },
             handleHotUpdate: {
                 async handler(ctx) {
+                    debugFileChange('handleHotUpdate()', ctx.file);
                     try {
                         return await handleHotUpdate(ctx, config);
                     }
@@ -86,9 +87,11 @@ function handleFileAddRemove(server, config) {
         file = normalizePath(file);
         if (isTemporaryBuildFile(file))
             return;
+        const operation = isRemove ? 'removed' : 'created';
+        debugFileChange('server.watcher', file, operation);
         const { moduleGraph } = server;
         const isVikeConfigDep = await isVikeConfigDependency(file, moduleGraph);
-        const reload = () => reloadConfig(file, config, isRemove ? 'removed' : 'created', server);
+        const reload = () => reloadConfig(file, config, operation, server);
         // Config code
         if (isVikeConfigDep && !isVikeConfigDep.isProcessedByVite) {
             reload();
@@ -127,6 +130,7 @@ function invalidateVikeVirtualFiles(server) {
 async function handleHotUpdate(ctx, config) {
     const { file, server } = ctx;
     const isVikeConfigDep = await isVikeConfigDependency(ctx.file, ctx.server.moduleGraph);
+    debugFileChange(isVikeConfigDep);
     if (isVikeConfigDep) {
         if (!isVikeConfigDep.isProcessedByVite) {
             /* Tailwind breaks this assertion, see https://github.com/vikejs/vike/discussions/1330#discussioncomment-7787238
@@ -141,11 +145,9 @@ async function handleHotUpdate(ctx, config) {
         }
         else {
             // Ensure we invalidate `file` *before* server.ssrLoadModule() in updateUserFiles()
-            // Vite already invalidates it, but *after* handleHotUpdate() and thus after server.ssrLoadModule()
+            // Vite also invalidates it, but *after* handleHotUpdate() and thus after server.ssrLoadModule()
             ctx.modules.forEach((mod) => server.moduleGraph.invalidateModule(mod));
-            if (isRunnable(server)) {
-                await updateUserFiles();
-            }
+            await updateUserFiles();
         }
     }
 }
@@ -172,12 +174,12 @@ async function isVikeConfigDependency(filePathAbsoluteFilesystem, moduleGraph) {
         return { isProcessedByVite: true };
     return null;
 }
-function reloadConfig(filePath, config, op, server) {
+function reloadConfig(filePath, config, operation, server) {
     // Ensure server.ssrLoadModule() loads fresh Vike virtual files (`reloadConfig()` > `updateUserFiles()` > `server.ssrLoadModule()`)
     invalidateVikeVirtualFiles(server);
     {
         const filePathToShowToUserResolved = getFilePathToShowToUserModule(filePath, config);
-        const msg = `${op} ${pc.dim(filePathToShowToUserResolved)}`;
+        const msg = `${operation} ${pc.dim(filePathToShowToUserResolved)}`;
         logConfigInfo(msg, 'info');
     }
     reloadVikeConfig();

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

@@ -114,6 +114,14 @@ const configDefinitionsBuiltIn = {
                 .flat(1)
                 // Server-only
                 .filter((source) => !source.configEnv.client)
+                // Exclude `.ssr.js` hooks (they don't require pageContext.json requests)
+                .filter((source) => {
+                const { definedAt } = source;
+                if ('filePathAbsoluteVite' in definedAt && definedAt.filePathAbsoluteVite.includes('.ssr.')) {
+                    return false;
+                }
+                return true;
+            })
                 // Config value isn't `null`
                 .filter((source) => !isConfigSourceValueNull(source));
             return sources.length > 0;

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

@@ -12,6 +12,7 @@ export { getConfigDefinitionOptional };
 export { getVikeConfigFromCliOrEnv };
 import { assertPosixPath, assert, isObject, assertUsage, assertWarning, objectEntries, hasProp, includes, assertIsNotProductionRuntime, getMostSimilar, joinEnglish, assertKeys, objectKeys, objectFromEntries, unique, isCallable, makeFirst, lowerFirst, makeLast, genPromise, checkType, objectAssign, getGlobalObject, } from '../utils.js';
 import { configDefinitionsBuiltIn, } from './resolveVikeConfigInternal/configDefinitionsBuiltIn.js';
+import { getFileSuffixes } from '../../../shared-server-node/getFileSuffixes.js';
 import { getLocationId, getFilesystemRouteString, getFilesystemRouteDefinedBy, isInherited, sortAfterInheritanceOrder, applyFilesystemRoutingRootEffect, } from './resolveVikeConfigInternal/filesystemRouting.js';
 import { getViteDevServer, vikeConfigErrorRecoverMsg } from '../../../server/runtime/globalContext.js';
 import { logConfigInfo, logErrorServerDev } from './loggerDev.js';
@@ -1066,16 +1067,16 @@ function getConfVal(plusFile, configName) {
 function resolveConfigEnv(configEnv, filePath) {
     const configEnvResolved = { ...configEnv };
     if (filePath.filePathAbsoluteFilesystem) {
-        const { fileName } = filePath;
-        if (fileName.includes('.server.')) {
+        const suffixes = getFileSuffixes(filePath.fileName);
+        if (suffixes.includes('ssr') || suffixes.includes('server')) {
             configEnvResolved.server = true;
             configEnvResolved.client = false;
         }
-        else if (fileName.includes('.client.')) {
+        else if (suffixes.includes('client')) {
             configEnvResolved.client = true;
             configEnvResolved.server = false;
         }
-        else if (fileName.includes('.shared.')) {
+        else if (suffixes.includes('shared')) {
             configEnvResolved.server = true;
             configEnvResolved.client = true;
         }

package/dist/server/runtime/globalContext.d.ts

@@ -17,7 +17,6 @@ export { setGlobalContext_prodBuildEntry };
 export { clearGlobalContext };
 export { assertBuildInfo };
 export { updateUserFiles };
-export { isRunnable };
 export { vikeConfigErrorRecoverMsg };
 export type { BuildInfo };
 export type { GlobalContextServerInternal };
@@ -466,4 +465,3 @@ declare function createGlobalContext(virtualFileExportsGlobalEntry: unknown): Pr
     prerenderContext: PrerenderContext | undefined;
 }>;
 declare function clearGlobalContext(): void;
-declare function isRunnable(viteDevServer: ViteDevServer): boolean;

package/dist/server/runtime/globalContext.js

@@ -19,7 +19,6 @@ export { setGlobalContext_prodBuildEntry }; // production entry
 export { clearGlobalContext };
 export { assertBuildInfo };
 export { updateUserFiles };
-export { isRunnable };
 export { vikeConfigErrorRecoverMsg };
 // The core logic revolves around:
 // - virtualFileExportsGlobalEntry is the main requirement
@@ -29,7 +28,7 @@ export { vikeConfigErrorRecoverMsg };
 //   - Without vike-server it's manually loaded here using importServerProductionEntry() which uses @brillout/vite-plugin-server-entry's autoImporter or crawler
 // - In development: globalObject.viteDevServer which is Vite's development server
 //   - globalObject.viteDevServer is used by updateUserFiles() which then sets virtualFileExportsGlobalEntry
-import { assert, onSetupRuntime, assertUsage, assertWarning, isPlainObject, objectReplace, isObject, hasProp, getGlobalObject, genPromise, createDebug, checkType, PROJECT_VERSION, getViteRPC, isRunnableDevEnvironment, assertIsNotBrowser, isNonRunnableDev, objectAssign, setNodeEnvProductionIfUndefined, } from '../utils.js';
+import { assert, onSetupRuntime, assertUsage, assertWarning, isPlainObject, objectReplace, isObject, hasProp, getGlobalObject, genPromise, createDebug, checkType, PROJECT_VERSION, getViteRPC, isRunnableDevEnvironment, assertIsNotBrowser, isNonRunnableDevProcess, objectAssign, setNodeEnvProductionIfUndefined, } from '../utils.js';
 import { importServerProductionEntry } from '@brillout/vite-plugin-server-entry/runtime';
 import { virtualFileIdGlobalEntryServer } from '../../shared-server-node/virtualFileId.js';
 import pc from '@brillout/picocolors';
@@ -39,7 +38,7 @@ import { resolveBase } from '../../shared-server-node/resolveBase.js';
 import { createGlobalContextShared, getGlobalContextSyncErrMsg, } from '../../shared-server-client/createGlobalContextShared.js';
 import { prepareGlobalContextForPublicUsage } from '../../shared-server-client/prepareGlobalContextForPublicUsage.js';
 import { logRuntimeError, logRuntimeInfo } from './loggerRuntime.js';
-import { getVikeConfigErrorBuild, setVikeConfigError } from '../../shared-server-node/getVikeConfigError.js';
+import { debugFileChange, getVikeConfigErrorBuild, setVikeConfigError, } from '../../shared-server-node/getVikeConfigError.js';
 import { getVikeApiOperation } from '../../shared-server-node/api-context.js';
 import { hasAlreadyLogged } from './logErrorServer.js';
 const debug = createDebug('vike:globalContext');
@@ -130,6 +129,7 @@ function getGlobalContextForPublicUsage() {
 }
 async function setGlobalContext_viteDevServer(viteDevServer) {
     debug('setGlobalContext_viteDevServer()');
+    assert(!isNonRunnableDevProcess()); // if `viteDevServer` exists => cannot be inside a non-runnable process
     // We cannot cache globalObject.viteDevServer because it's fully replaced when the user modifies vite.config.js => Vite's dev server is fully reloaded and a new viteDevServer replaces the previous one.
     if (!globalObject.viteDevServer) {
         assertIsNotInitializedYet();
@@ -137,12 +137,10 @@ async function setGlobalContext_viteDevServer(viteDevServer) {
     assert(globalObject.viteConfig);
     globalObject.viteDevServer = viteDevServer;
     globalObject.viteDevServerPromiseResolve(viteDevServer);
-    if (isRunnable(viteDevServer)) {
-        const { success } = await updateUserFiles();
-        if (!success)
-            return;
-        assertGlobalContextIsDefined();
-    }
+    const { success } = await updateUserFiles();
+    if (!success)
+        return;
+    assertGlobalContextIsDefined();
 }
 function setGlobalContext_viteConfig(viteConfig, viteConfigRuntime) {
     if (globalObject.viteConfig)
@@ -210,7 +208,7 @@ async function initGlobalContext() {
             await globalObject.viteDevServerPromise;
         }
         else {
-            assert(isNonRunnableDev());
+            assert(isNonRunnableDevProcess());
             await updateUserFiles();
         }
         assert(globalObject.waitForUserFilesUpdate);
@@ -268,7 +266,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());
+    assert(!isNonRunnableDevProcess());
     assertProdBuildEntry(prodBuildEntry);
     setNodeEnvProductionIfUndefined();
     globalObject.prodBuildEntry = prodBuildEntry;
@@ -307,48 +305,28 @@ function assertVersionAtBuildTime(versionAtBuildTime) {
     const pretty = (version) => pc.bold(`vike@${version}`);
     assertUsage(versionAtBuildTime === versionAtRuntime, `Re-build your app (you're using ${pretty(versionAtRuntime)} but your app was built with ${pretty(versionAtBuildTime)})`);
 }
-// TODO: recover from +onCreateGlobalContext runtime error doesn't work
 async function updateUserFiles() {
-    debug('updateUserFiles()');
+    debugUpdate();
     assert(!isProd());
+    const { viteDevServer } = globalObject;
+    const isRunnableServer = !!viteDevServer && isRunnableDevServer(viteDevServer);
+    const isNonRunnableProcess = isNonRunnableDevProcess();
+    if (!isRunnableServer && !isNonRunnableProcess) {
+        // Not the runtime process — it's the Vite process and not the non-runnable process
+        debugUpdate('=> aborted: not runtime');
+        return { success: false };
+    }
     const { promise, resolve } = genPromise();
     globalObject.waitForUserFilesUpdate = promise;
     globalObject.waitForUserFilesUpdateResolve ?? (globalObject.waitForUserFilesUpdateResolve = []);
     globalObject.waitForUserFilesUpdateResolve.push(resolve);
-    const onError = (err) => {
-        if (
-        // We must check whether the error was already logged to avoid printing it twice, e.g. when +onCreateGlobalContext.js has a syntax error
-        !hasAlreadyLogged(err)) {
-            logRuntimeError(err, null);
-        }
-        setVikeConfigError({ errorRuntime: { err } });
-        globalObject.vikeConfigHasRuntimeError = true;
-        return { success: false };
-    };
-    const onSuccess = () => {
-        if (globalObject.vikeConfigHasRuntimeError) {
-            assert(logRuntimeInfo); // always defined in dev
-            logRuntimeInfo(vikeConfigErrorRecoverMsg, null, 'error-resolve');
-        }
-        globalObject.vikeConfigHasRuntimeError = false;
-        setVikeConfigError({ errorRuntime: false });
-        globalObject.waitForUserFilesUpdateResolve.forEach((resolve) => resolve());
-        globalObject.waitForUserFilesUpdateResolve = [];
-        resolve();
-        return { success: true };
-    };
-    const isOutdated = () => 
-    // There is a newer call — let the new call supersede the old one.
-    // We deliberately swallow the intermetidate state (including any potential error) — it's now outdated and has existed only for a very short period of time.
-    globalObject.waitForUserFilesUpdate !== promise ||
-        // Avoid race condition: abort if there is a new globalObject.viteDevServer (happens when vite.config.js is modified => Vite's dev server is fully reloaded).
-        viteDevServer !== globalObject.viteDevServer;
-    const { viteDevServer } = globalObject;
     let hasError = false;
     let virtualFileExportsGlobalEntry;
     let err;
-    if (viteDevServer) {
-        assert(isRunnable(viteDevServer));
+    if (isRunnableServer) {
+        assert(viteDevServer);
+        assert(isRunnableDevServer(viteDevServer));
+        assert(!isNonRunnableProcess);
         /* We don't use runner.import() yet, because as of vite@7.0.6 (July 2025) runner.import() unexpectedly invalidates the module graph, which is a unexpected behavior that doesn't happen with ssrLoadModule()
         // Vite 6
         try {
@@ -370,6 +348,8 @@ async function updateUserFiles() {
         }
     }
     else {
+        assert(isNonRunnableProcess);
+        assert(!viteDevServer);
         try {
             // We don't directly use import() because:
             // - Avoid Cloudflare Workers (without @cloudflare/vite-plugin) to try to bundle `import('virtual:id')`.
@@ -392,6 +372,7 @@ async function updateUserFiles() {
         return onError(err);
     virtualFileExportsGlobalEntry = virtualFileExportsGlobalEntry.default || virtualFileExportsGlobalEntry;
     if (getVikeConfigErrorBuild()) {
+        debugUpdate('=> aborted: build error');
         return { success: false };
     }
     try {
@@ -406,6 +387,45 @@ async function updateUserFiles() {
     if (hasError)
         return onError(err);
     return onSuccess();
+    function onSuccess() {
+        debugUpdate('=> onSuccess()');
+        if (globalObject.vikeConfigHasRuntimeError) {
+            assert(logRuntimeInfo); // always defined in dev
+            logRuntimeInfo(vikeConfigErrorRecoverMsg, null, 'error-resolve');
+        }
+        globalObject.vikeConfigHasRuntimeError = false;
+        setVikeConfigError({ errorRuntime: false });
+        globalObject.waitForUserFilesUpdateResolve.forEach((resolve) => resolve());
+        globalObject.waitForUserFilesUpdateResolve = [];
+        resolve();
+        return { success: true };
+    }
+    function onError(err) {
+        debugUpdate('=> onError()');
+        if (
+        // We must check whether the error was already logged to avoid printing it twice, e.g. when +onCreateGlobalContext.js has a syntax error
+        !hasAlreadyLogged(err)) {
+            logRuntimeError(err, null);
+        }
+        setVikeConfigError({ errorRuntime: { err } });
+        globalObject.vikeConfigHasRuntimeError = true;
+        return { success: false };
+    }
+    function isOutdated() {
+        const yes = 
+        // There is a newer call — let the new call supersede the old one.
+        // We deliberately swallow the intermetidate state (including any potential error) — it's now outdated and has existed only for a very short period of time.
+        globalObject.waitForUserFilesUpdate !== promise ||
+            // Avoid race condition: abort if there is a new globalObject.viteDevServer (happens when vite.config.js is modified => Vite's dev server is fully reloaded).
+            viteDevServer !== globalObject.viteDevServer;
+        if (yes)
+            debugUpdate('=> aborted: isOutdated');
+        return yes;
+    }
+    function debugUpdate(...args) {
+        debug('updateUserFiles()', ...args);
+        debugFileChange('updateUserFiles()', ...args);
+    }
 }
 async function createGlobalContext(virtualFileExportsGlobalEntry) {
     debug('createGlobalContext()');
@@ -496,7 +516,7 @@ async function addGlobalContextAsync(globalContext) {
         else {
             assert(!isProcessSharedWithVite()); // process shared with Vite => globalObject.viteConfigRuntime should be set
             assert(!isProd()); // production => globalObject.buildInfo.viteConfigRuntime should be set
-            assert(isNonRunnableDev());
+            assert(isNonRunnableDevProcess());
             const rpc = getViteRPC();
             viteConfigRuntime = await rpc.getViteConfigRuntimeRPC();
         }
@@ -528,17 +548,16 @@ function resolveBaseRuntime(viteConfigRuntime, config) {
 function isProcessSharedWithVite() {
     const yes = globalThis.__VIKE__IS_PROCESS_SHARED_WITH_VITE ?? false;
     if (yes)
-        assert(!isNonRunnableDev());
+        assert(!isNonRunnableDevProcess());
     return yes;
 }
-function isRunnable(viteDevServer) {
+function isRunnableDevServer(viteDevServer) {
+    assert(!isNonRunnableDevProcess()); // if `viteDevServer` exists => cannot be inside a non-runnable process
     const yes = 
     // Vite 5
     !viteDevServer.environments ||
         // Vite 6 or above
         isRunnableDevEnvironment(viteDevServer.environments.ssr);
-    if (yes)
-        assert(!isNonRunnableDev());
     return yes;
 }
 function isProd() {
@@ -577,7 +596,7 @@ function isProdOptional() {
     // getGlobalContextAsync(isProduction)
     const no4 = globalObject.isProductionAccordingToUser === false;
     // @cloudflare/vite-plugin
-    const no5 = isNonRunnableDev();
+    const no5 = isNonRunnableDevProcess();
     const no6 = globalThis.__VIKE__IS_DEV === true;
     const no = no1 || no2 || no3 || no4 || no5 || no6;
     const debug = { yes1, yes2, yes3, yes4, yes5, yes6, yes7, no1, no2, no3, no4, no5, no6 };

package/dist/server/runtime/renderPageServer/execHookServer.js

@@ -1,6 +1,13 @@
 export { execHookServer };
-import { execHook } from '../../../shared-server-client/hooks/execHook.js';
+import { execHookDirect } from '../../../shared-server-client/hooks/execHook.js';
 import { preparePageContextForPublicUsageServer, } from './preparePageContextForPublicUsageServer.js';
+import { getHookFromPageContextNew } from '../../../shared-server-client/hooks/getHook.js';
+import { getFileSuffixes } from '../../../shared-server-node/getFileSuffixes.js';
 async function execHookServer(hookName, pageContext) {
-    return await execHook(hookName, pageContext, preparePageContextForPublicUsageServer);
+    const allHooks = getHookFromPageContextNew(hookName, pageContext);
+    const hooks = !pageContext.isClientSideNavigation
+        ? allHooks
+        : // Don't execute `.ssr.js` hooks upon client-side navigation
+            allHooks.filter((hook) => !getFileSuffixes(hook.hookFilePath).includes('ssr'));
+    return await execHookDirect(hooks, pageContext, preparePageContextForPublicUsageServer);
 }

package/dist/server/runtime/renderPageServer.js

@@ -219,17 +219,14 @@ function logHttpRequest(urlOriginal, pageContextInit, requestId) {
     const pageContext_logRuntime = getPageContext_logRuntimeEarly(pageContextInit, requestId);
     logRuntimeInfo?.(getRequestInfoMessage(urlOriginal), pageContext_logRuntime, 'info');
 }
-/*
-const arrowRight = pc.dim('→')
-const arrowLeft = pc.dim('←')
-*/
-/*
+/* Alternative icons:
+const arrowRight = pc.dim('»')
+const arrowLeft = pc.dim('«')
 const arrowRight = pc.dim('>>')
 const arrowLeft = pc.dim('<<')
-/*/
-const arrowRight = pc.dim('»');
-const arrowLeft = pc.dim('«');
-//*/
+*/
+const arrowRight = pc.dim('→');
+const arrowLeft = pc.dim('←');
 function getRequestInfoMessage(urlOriginal) {
     return `HTTP request  ${arrowRight} ${prettyUrl(urlOriginal)}`;
 }

package/dist/server/utils.d.ts

@@ -60,6 +60,6 @@ export * from '../utils/changeEnumerable.js';
 export * from '../utils/getViteRPC.js';
 export * from '../utils/isRunnableDevEnvironment.js';
 export * from '../utils/assertIsNotBrowser.js';
-export * from '../utils/isNonRunnableDev.js';
+export * from '../utils/isNonRunnableDevProcess.js';
 export * from '../utils/catchInfiniteLoop.js';
 export * from '../utils/getBetterError.js';

package/dist/server/utils.js

@@ -64,6 +64,6 @@ export * from '../utils/changeEnumerable.js';
 export * from '../utils/getViteRPC.js';
 export * from '../utils/isRunnableDevEnvironment.js';
 export * from '../utils/assertIsNotBrowser.js';
-export * from '../utils/isNonRunnableDev.js';
+export * from '../utils/isNonRunnableDevProcess.js';
 export * from '../utils/catchInfiniteLoop.js';
 export * from '../utils/getBetterError.js';

package/dist/shared-server-client/assertVirtualFileExports.d.ts

@@ -0,0 +1,2 @@
+export { assertVirtualFileExports };
+declare function assertVirtualFileExports<ModuleExports>(moduleExports: ModuleExports, test: (moduleExports: ModuleExports) => boolean, moduleId?: string): void;

package/dist/shared-server-client/assertVirtualFileExports.js

@@ -0,0 +1,16 @@
+export { assertVirtualFileExports };
+import { assert } from './utils.js';
+function assertVirtualFileExports(moduleExports, test, moduleId) {
+    if (!moduleExports || !test(moduleExports)) {
+        /* https://github.com/vikejs/vike/issues/2903#issuecomment-3642285811
+        throw getProjectError('@cloudflare/vite-plugin error https://github.com/vikejs/vike/issues/2903#issuecomment-3642285811')
+        /*/
+        assert(false, { moduleExports, moduleExportsKeys: getKeys(moduleExports), moduleId });
+        //*/
+    }
+}
+function getKeys(obj) {
+    if (obj === undefined)
+        return null;
+    return [...Object.getOwnPropertyNames(obj), ...Object.getOwnPropertySymbols(obj), ...Object.keys(obj)];
+}

package/dist/shared-server-client/createGlobalContextShared.js

@@ -24,50 +24,54 @@ addGlobalContextTmp, addGlobalContextAsync) {
         assert(globalObject.globalContext);
         await previousCreateGlobalContextPromise;
     }
-    const globalContext = createGlobalContextBase(virtualFileExportsGlobalEntry);
-    let isNewGlobalContext;
-    if (!globalObject.globalContext) {
-        // We set globalObject.globalContext early and before any async operations, so that getGlobalContextSync() can be used early.
-        // - Required by vike-vercel
-        globalObject.globalContext = globalContext;
-        isNewGlobalContext = false;
-    }
-    else {
-        isNewGlobalContext = true;
-    }
-    if (addGlobalContext &&
-        // TO-DO/next-major-release: remove
-        globalContext._pageConfigs.length > 0) {
-        const globalContextAdded = addGlobalContext?.(globalContext);
-        objectAssign(globalContext, globalContextAdded);
-    }
-    else {
-        const globalContextAdded = await addGlobalContextTmp?.(globalContext);
-        objectAssign(globalContext, globalContextAdded);
-    }
-    {
-        const globalContextAddedAsync = await addGlobalContextAsync?.(globalContext);
-        objectAssign(globalContext, globalContextAddedAsync);
-    }
-    const onCreateGlobalContextHooks = getHookFromPageConfigGlobalCumulative(globalContext._pageConfigGlobal, 'onCreateGlobalContext');
-    let hooksCalled = false;
-    if (!hooksAreEqual(globalObject.onCreateGlobalContextHooks ?? [], onCreateGlobalContextHooks)) {
-        globalObject.onCreateGlobalContextHooks = onCreateGlobalContextHooks;
-        await execHookGlobal('onCreateGlobalContext', globalContext._pageConfigGlobal, null, globalContext, prepareGlobalContextForPublicUsage);
-        hooksCalled = true;
-    }
-    if (isNewGlobalContext) {
-        // Singleton: ensure all `globalContext` user-land references are preserved & updated.
-        if (hooksCalled) {
-            objectReplace(globalObject.globalContext, globalContext);
+    try {
+        const globalContext = createGlobalContextBase(virtualFileExportsGlobalEntry);
+        let isNewGlobalContext;
+        if (!globalObject.globalContext) {
+            // We set globalObject.globalContext early and before any async operations, so that getGlobalContextSync() can be used early.
+            // - Required by vike-vercel
+            globalObject.globalContext = globalContext;
+            isNewGlobalContext = false;
         }
         else {
-            // We don't use objectReplace() in order to keep user-land properties.
-            objectAssign(globalObject.globalContext, globalContext, true);
+            isNewGlobalContext = true;
+        }
+        if (addGlobalContext &&
+            // TO-DO/next-major-release: remove
+            globalContext._pageConfigs.length > 0) {
+            const globalContextAdded = addGlobalContext?.(globalContext);
+            objectAssign(globalContext, globalContextAdded);
         }
+        else {
+            const globalContextAdded = await addGlobalContextTmp?.(globalContext);
+            objectAssign(globalContext, globalContextAdded);
+        }
+        {
+            const globalContextAddedAsync = await addGlobalContextAsync?.(globalContext);
+            objectAssign(globalContext, globalContextAddedAsync);
+        }
+        const onCreateGlobalContextHooks = getHookFromPageConfigGlobalCumulative(globalContext._pageConfigGlobal, 'onCreateGlobalContext');
+        let hooksCalled = false;
+        if (!hooksAreEqual(globalObject.onCreateGlobalContextHooks ?? [], onCreateGlobalContextHooks)) {
+            globalObject.onCreateGlobalContextHooks = onCreateGlobalContextHooks;
+            await execHookGlobal('onCreateGlobalContext', globalContext._pageConfigGlobal, null, globalContext, prepareGlobalContextForPublicUsage);
+            hooksCalled = true;
+        }
+        if (isNewGlobalContext) {
+            // Singleton: ensure all `globalContext` user-land references are preserved & updated.
+            if (hooksCalled) {
+                objectReplace(globalObject.globalContext, globalContext);
+            }
+            else {
+                // We don't use objectReplace() in order to keep user-land properties.
+                objectAssign(globalObject.globalContext, globalContext, true);
+            }
+        }
+        return globalObject.globalContext;
+    }
+    finally {
+        resolve();
     }
-    resolve();
-    return globalObject.globalContext;
 }
 function createGlobalContextBase(virtualFileExportsGlobalEntry) {
     const { pageFilesAll, pageConfigs, pageConfigGlobal } = parseVirtualFileExportsGlobalEntry(virtualFileExportsGlobalEntry);

package/dist/shared-server-client/getPageFiles/parseVirtualFileExportsGlobalEntry.js

@@ -5,7 +5,9 @@ import { assertExportValues } from './assert_exports_old_design.js';
 import { getPageFileObject } from './getPageFileObject.js';
 import { fileTypes } from './fileTypes.js';
 import { parsePageConfigsSerialized } from '../page-configs/serialize/parsePageConfigsSerialized.js';
+import { assertVirtualFileExports } from '../assertVirtualFileExports.js';
 function parseVirtualFileExportsGlobalEntry(virtualFileExportsGlobalEntry) {
+    assertVirtualFileExports(virtualFileExportsGlobalEntry, (moduleExports) => 'pageFilesLazy' in moduleExports);
     assert(hasProp(virtualFileExportsGlobalEntry, 'pageFilesLazy', 'object'));
     assert(hasProp(virtualFileExportsGlobalEntry, 'pageFilesEager', 'object'));
     assert(hasProp(virtualFileExportsGlobalEntry, 'pageFilesExportNamesLazy', 'object'));

package/dist/shared-server-client/page-configs/loadAndParseVirtualFilePageEntry.js

@@ -1,6 +1,7 @@
 export { loadAndParseVirtualFilePageEntry };
-import { assert, objectAssign } from '../utils.js';
+import { objectAssign } from '../utils.js';
 import { parseConfigValuesSerialized } from './serialize/parsePageConfigsSerialized.js';
+import { assertVirtualFileExports } from '../assertVirtualFileExports.js';
 async function loadAndParseVirtualFilePageEntry(pageConfig, isDev) {
     if ('isPageEntryLoaded' in pageConfig &&
         // We don't need to cache in dev, since Vite already caches the virtual module
@@ -8,10 +9,13 @@ async function loadAndParseVirtualFilePageEntry(pageConfig, isDev) {
         return pageConfig;
     }
     const { moduleId, moduleExportsPromise } = pageConfig.loadVirtualFilePageEntry();
-    const virtualFileExportsPageEntry = await moduleExportsPromise;
-    // `configValuesLoaded` is sometimes `undefined` https://github.com/vikejs/vike/discussions/2092
-    if (!virtualFileExportsPageEntry)
-        assert(false, { moduleExportsPromise, virtualFileExportsPageEntry, moduleId });
+    const moduleExports = await moduleExportsPromise;
+    /* `moduleExports` is sometimes `undefined` https://github.com/vikejs/vike/discussions/2092
+    assert(moduleExports)
+    //*/
+    // Catch @cloudflare/vite-plugin bug
+    assertVirtualFileExports(moduleExports, () => 'configValuesSerialized' in moduleExports, moduleId);
+    const virtualFileExportsPageEntry = moduleExports;
     const configValues = parseVirtualFileExportsPageEntry(virtualFileExportsPageEntry);
     Object.assign(pageConfig.configValues, configValues);
     objectAssign(pageConfig, { isPageEntryLoaded: true });

package/dist/shared-server-node/getFileSuffixes.d.ts

@@ -0,0 +1,6 @@
+export { getFileSuffixes };
+export { suffixesAssertFileEnv };
+declare const suffixesAssertFileEnv: readonly ["server", "client", "ssr"];
+declare const suffixes: readonly ["server", "client", "ssr", "shared", "clear", "default"];
+type Suffix = (typeof suffixes)[number];
+declare function getFileSuffixes(fileName: string): Suffix[];

package/dist/shared-server-node/getFileSuffixes.js

@@ -0,0 +1,22 @@
+export { getFileSuffixes };
+export { suffixesAssertFileEnv };
+const suffixesAssertFileEnv = [
+    // .server.js
+    'server',
+    // .client.js
+    'client',
+    // .ssr.js
+    'ssr',
+];
+const suffixes = [
+    ...suffixesAssertFileEnv,
+    // .shared.js
+    'shared',
+    // .clear.js
+    'clear',
+    // .default.js
+    'default',
+];
+function getFileSuffixes(fileName) {
+    return suffixes.filter((suffix) => fileName.includes(`.${suffix}.`));
+}

package/dist/shared-server-node/getVikeConfigError.d.ts

@@ -1,6 +1,15 @@
 export { getVikeConfigError };
 export { getVikeConfigErrorBuild };
 export { setVikeConfigError };
+export { debugFileChange };
+declare const debugFileChange: ((...msgs: unknown[]) => void) & {
+    options: (optionsLocal: {
+        serialization?: {
+            emptyArray?: string;
+        };
+    }) => (...msgs: unknown[]) => void;
+    isActivated: boolean;
+};
 type VikeConfigHasError = false | {
     err: unknown;
 };

package/dist/shared-server-node/getVikeConfigError.js

@@ -1,12 +1,15 @@
 export { getVikeConfigError };
 export { getVikeConfigErrorBuild };
 export { setVikeConfigError };
-import { getGlobalObject } from './utils.js';
+export { debugFileChange };
+import { getGlobalObject, createDebug } from './utils.js';
 const globalObject = getGlobalObject('server/shared/getVikeConfigError.ts', {
     errorRuntime: false,
     errorBuild: false,
 });
+const debugFileChange = createDebug('vike:file-change');
 function setVikeConfigError(val) {
+    debugFileChange('setVikeConfigError()', val);
     if ('errorRuntime' in val)
         globalObject.errorRuntime = val.errorRuntime;
     if ('errorBuild' in val)

package/dist/utils/PROJECT_VERSION.d.ts

@@ -1 +1 @@
-export declare const PROJECT_VERSION: "0.4.247-commit-87e5f2f";
+export declare const PROJECT_VERSION: "0.4.247-commit-1250e38";

package/dist/utils/PROJECT_VERSION.js

@@ -1,2 +1,2 @@
 // Automatically updated by @brillout/release-me
-export const PROJECT_VERSION = '0.4.247-commit-87e5f2f';
+export const PROJECT_VERSION = '0.4.247-commit-1250e38';

package/dist/utils/assertSetup.js

@@ -12,7 +12,7 @@ import { assert, assertUsage, assertWarning } from './assert.js';
 import { assertIsNotBrowser } from './assertIsNotBrowser.js';
 import { createDebug } from './debug.js';
 import { getGlobalObject } from './getGlobalObject.js';
-import { isNonRunnableDev } from './isNonRunnableDev.js';
+import { isNonRunnableDevProcess } from './isNonRunnableDevProcess.js';
 import { isVitest } from './isVitest.js';
 import pc from '@brillout/picocolors';
 assertIsNotBrowser();
@@ -32,9 +32,9 @@ function onSetupRuntime() {
     assertNodeEnvIsNotUndefinedString();
     if (!setup.viteDevServer && setup.isViteDev === undefined) {
         // TO-DO/eventually: make it assertUsage() again once https://github.com/vikejs/vike/issues/1528 is implemented.
-        assertWarning(!isNodeEnvDev() || isNonRunnableDev(), `The ${getEnvDescription()}, which is contradictory because the environment seems to be a production environment (Vite isn't loaded), see ${pc.underline('https://vike.dev/NODE_ENV')} and ${pc.underline('https://vike.dev/warning/setup')}`, { onlyOnce: true });
+        assertWarning(!isNodeEnvDev() || isNonRunnableDevProcess(), `The ${getEnvDescription()}, which is contradictory because the environment seems to be a production environment (Vite isn't loaded), see ${pc.underline('https://vike.dev/NODE_ENV')} and ${pc.underline('https://vike.dev/warning/setup')}`, { onlyOnce: true });
         assertUsage(!setup.vikeVitePlugin, `Vike's Vite plugin (the ${pc.cyan('vike/plugin')} module) shouldn't be loaded in production, see ${pc.underline('https://vike.dev/warning/setup')}`);
-        // This assert() one of the main goal of this file: it ensures assertIsNotProductionRuntime()
+        // This assert() one of the main goal of this file: it implements assertIsNotProductionRuntime()
         assert(!setup.shouldNotBeProduction);
     }
     else {

package/dist/utils/debug.d.ts

@@ -2,7 +2,7 @@ export { createDebug };
 export { isDebug };
 export { isDebugError };
 export { debug };
-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"];
+declare const flags: ["vike", "vike:crawl", "vike:file-change", "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 Options = {
     serialization?: {

package/dist/utils/debug.js

@@ -12,6 +12,7 @@ import { isObject } from './isObject.js';
 const flags = [
     'vike',
     'vike:crawl',
+    'vike:file-change',
     'vike:error',
     'vike:esbuild-resolve',
     'vike:pluginExtractAssets',

package/dist/utils/getBetterError.js

@@ -1,5 +1,8 @@
 export { getBetterError };
 // TO-DO/maybe: make it a library `@brillout/better-error`
+// Copies:
+// - https://github.com/brillout/react-streaming/blob/b8565c1257c63a665bda31b9be42112e458859d1/src/utils/getBetterError.ts
+// - https://github.com/vikejs/vike-react/blob/5477461e67592e24d2aa38a552703b9e76a01d2a/packages/vike-react/src/utils/getBetterErrorLight.ts
 import { isObject } from './isObject.js';
 import { assertIsNotBrowser } from './assertIsNotBrowser.js';
 import { objectAssign } from './objectAssign.js';

package/dist/utils/isNonRunnableDevProcess.d.ts

@@ -0,0 +1,2 @@
+export { isNonRunnableDevProcess };
+declare function isNonRunnableDevProcess(): boolean;

package/dist/utils/{isNonRunnableDev.js → isNonRunnableDevProcess.js}

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.247-commit-87e5f2f",
+  "version": "0.4.247-commit-1250e38",
   "repository": "https://github.com/vikejs/vike",
   "exports": {
     "./server": {
@@ -244,13 +244,13 @@
     "./universal-middleware.js"
   ],
   "devDependencies": {
-    "@brillout/release-me": "^0.4.2",
+    "@brillout/release-me": "^0.4.9",
     "@types/estree": "^1.0.5",
     "@types/node": "^20.10.5",
     "@types/picomatch": "^3.0.2",
     "@types/semver": "^7.5.8",
     "@types/source-map-support": "^0.5.10",
-    "react-streaming": "^0.4.13",
+    "react-streaming": "^0.4.14",
     "rimraf": "^5.0.5",
     "typescript": "^5.9.3",
     "vite": "^7.2.6"

package/dist/node/vite/plugins/pluginDev/determineOptimizeDeps.d.ts

@@ -1,3 +0,0 @@
-export { determineOptimizeDeps };
-import type { ResolvedConfig } from 'vite';
-declare function determineOptimizeDeps(config: ResolvedConfig): Promise<void>;

package/dist/node/vite/plugins/pluginFileEnv.d.ts

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

package/dist/utils/isNonRunnableDev.d.ts

@@ -1,2 +0,0 @@
-export { isNonRunnableDev };
-declare function isNonRunnableDev(): boolean;