vike 0.4.247-commit-e331796 → 0.4.247-commit-1250e38

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-e331796";
+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-e331796';
+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-e331796",
+  "version": "0.4.247-commit-1250e38",
   "repository": "https://github.com/vikejs/vike",
   "exports": {
     "./server": {
@@ -104,6 +104,10 @@
       "types": "./dist/server/runtime/page-files/setup.d.ts",
       "default": "./dist/server/runtime/page-files/setup.js"
     },
+    "./__internal/vite": {
+      "types": "./dist/server/__internal/vite.d.ts",
+      "default": "./dist/server/__internal/vite.js"
+    },
     ".": {
       "worker": "./dist/server/runtime/index.js",
       "workerd": "./dist/server/runtime/index.js",
@@ -240,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"