vike 0.4.156-commit-d07fbe8 → 0.4.156-commit-e46716d

package/dist/cjs/node/plugin/plugins/commonConfig.js

@@ -4,7 +4,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.commonConfig = void 0;
-const vite_1 = require("vite");
 const utils_js_1 = require("../utils.js");
 const buildConfig_js_1 = require("./buildConfig.js");
 const require_shim_1 = require("@brillout/require-shim");
@@ -30,7 +29,9 @@ function commonConfig() {
                 order: 'post',
                 handler(config) {
                     overrideViteDefaultPort(config);
-                    overrideViteDefaultSsrExternal(config);
+                    /* TODO: do this after implementing vike.config.js and new setting transformLinkedDependencies (or probably a better name like transpileLinkedDependencies/bundleLinkedDependencies or something else)
+                    overrideViteDefaultSsrExternal(config)
+                    */
                     workaroundCI(config);
                     (0, buildConfig_js_1.assertRollupInput)(config);
                     (0, assertResolveAlias_js_1.assertResolveAlias)(config);
@@ -50,13 +51,22 @@ function overrideViteDefaultPort(config) {
     config.preview ?? (config.preview = {});
     (_b = config.preview).port ?? (_b.port = 3000);
 }
-function overrideViteDefaultSsrExternal(config) {
-    var _a;
-    if (!isViteVersionWithSsrExternalTrue())
-        return;
-    // @ts-ignore Not released yet: https://github.com/vitejs/vite/pull/10939/files#diff-5a3d42620df2c6b17e25f440ffdb67683dee7ef57317674d19f41d5f30502310L5
-    (_a = config.ssr).external ?? (_a.external = true);
+/*
+function overrideViteDefaultSsrExternal(config: ResolvedConfig) {
+  if (!isViteVersionWithSsrExternalTrue()) return
+  // @ts-ignore Not released yet: https://github.com/vitejs/vite/pull/10939/files#diff-5a3d42620df2c6b17e25f440ffdb67683dee7ef57317674d19f41d5f30502310L5
+  config.ssr.external ??= true
+}
+import { version } from 'vite'
+function isViteVersionWithSsrExternalTrue(): boolean {
+  const versionParts = version.split('.').map((s) => parseInt(s, 10)) as [number, number, number]
+  assert(versionParts.length === 3)
+  if (versionParts[0] > 5) return true
+  if (versionParts[1] > 0) return true
+  if (versionParts[2] >= 12) return true
+  return false
 }
+*/
 // Workaround GitHub Action failing to access the server
 function workaroundCI(config) {
     var _a, _b;
@@ -79,14 +89,3 @@ function assertEsm(userViteRoot) {
     dir = picocolors_1.default.dim(dir);
     (0, utils_js_1.assertWarning)(packageJson.type === 'module', `We recommend setting ${dir}package.json#type to "module", see https://vike.dev/CJS`, { onlyOnce: true });
 }
-function isViteVersionWithSsrExternalTrue() {
-    const versionParts = vite_1.version.split('.').map((s) => parseInt(s, 10));
-    (0, utils_js_1.assert)(versionParts.length === 3);
-    if (versionParts[0] > 5)
-        return true;
-    if (versionParts[1] > 0)
-        return true;
-    if (versionParts[2] >= 12)
-        return true;
-    return false;
-}

package/dist/cjs/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/crawlPlusFiles.js

@@ -145,6 +145,8 @@ async function isGitMissing(userRootDir) {
 }
 async function runCmd(cmd, cwd) {
     const res = await execA(cmd, { cwd });
-    (0, utils_js_1.assert)(res.stderr === '');
+    /* Not always true: https://github.com/vikejs/vike/issues/1440#issuecomment-1892831303
+    assert(res.stderr === '')
+    */
     return res.stdout.toString().split('\n').filter(Boolean);
 }

package/dist/cjs/node/plugin/plugins/importUserCode/v1-design/getVikeConfig.js

@@ -841,6 +841,7 @@ function getConfigName(filePath) {
     }
     else {
         const configName = basename.slice(1);
+        (0, utils_js_1.assertUsage)(configName !== '', `${filePath} Invalid filename ${fileName}`);
         return configName;
     }
 }
@@ -1033,6 +1034,7 @@ function resolveImportPath(importData, importerFilePath) {
     const importerFilePathAbsolute = importerFilePath.filePathAbsoluteFilesystem;
     (0, utils_js_1.assertPosixPath)(importerFilePathAbsolute);
     const cwd = path_1.default.posix.dirname(importerFilePathAbsolute);
+    // We can't use import.meta.resolve() as of Junary 2023 (and probably for a lot longer): https://stackoverflow.com/questions/54977743/do-require-resolve-for-es-modules#comment137174954_62272600:~:text=But%20the%20argument%20parent%20(aka%20cwd)%20still%20requires%20a%20flag
     // filePathAbsoluteFilesystem is expected to be null when importData.importPath is a Vite path alias
     const filePathAbsoluteFilesystem = (0, utils_js_1.requireResolve)(importData.importPath, cwd);
     return filePathAbsoluteFilesystem;

package/dist/cjs/node/plugin/plugins/importUserCode/v1-design/getVirtualFilePageConfigs.js

@@ -52,6 +52,8 @@ function getCodePageConfigsSerialized(pageConfigs, isForClientSide, isClientRout
             (0, utils_js_1.assert)(configValueSource);
             if (!configValueSource.configEnv.eager)
                 return;
+            if (!(0, isRuntimeEnvMatch_js_1.isRuntimeEnvMatch)(configValueSource.configEnv, { isForClientSide, isClientRouting, isEager: true }))
+                return;
             lines.push(...(0, serializeConfigValue_js_1.serializeConfigValueImported)(configValueSource, configName, whitespace, varCounterContainer, importStatements));
         });
         lines.push(`${whitespace}],`);

package/dist/cjs/node/prerender/runPrerender.js

@@ -54,6 +54,8 @@ const getVikeConfig_js_1 = require("../plugin/plugins/importUserCode/v1-design/g
 const logHintForCjsEsmError_js_1 = require("../runtime/renderPage/logHintForCjsEsmError.js");
 async function runPrerenderFromAPI(options = {}) {
     await runPrerender(options, 'prerender()');
+    // - We purposely propagate the error to the user land, so that the error interrupts the user land. It's also, I guess, a nice-to-have that the user has control over the error.
+    // - We don't use logHintForCjsEsmError() because we don't have control over what happens with the error. For example, if the user land purposely swallows the error then the hint shouldn't be logged. Also, it's best if the hint is shown to the user *after* the error, but we cannot do/guarentee that.
 }
 exports.runPrerenderFromAPI = runPrerenderFromAPI;
 async function runPrerenderFromCLI(options) {

package/dist/cjs/node/runtime/html/serializePageContextClientSide.js

@@ -11,7 +11,7 @@ const addIs404ToPageProps_js_1 = require("../../../shared/addIs404ToPageProps.js
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const notSerializable_js_1 = require("../../../shared/notSerializable.js");
 const pageContextInitIsPassedToClient_js_1 = require("../../../shared/misc/pageContextInitIsPassedToClient.js");
-const isRenderFailure_js_1 = require("../../../shared/misc/isRenderFailure.js");
+const isServerSideError_js_1 = require("../../../shared/misc/isServerSideError.js");
 const PASS_TO_CLIENT = [
     'abortReason',
     '_urlRewrite',
@@ -25,7 +25,7 @@ const PASS_TO_CLIENT = [
     '_pageId',
     'data' // for data() hook
 ];
-const PASS_TO_CLIENT_ERROR_PAGE = ['pageProps', 'is404', isRenderFailure_js_1.isRenderFailure];
+const PASS_TO_CLIENT_ERROR_PAGE = ['pageProps', 'is404', isServerSideError_js_1.isServerSideError];
 function serializePageContextClientSide(pageContext) {
     const passToClient = getPassToClient(pageContext);
     const pageContextClient = {};

package/dist/cjs/node/runtime/renderPage/isNewError.js

@@ -7,7 +7,9 @@ const globalObject = (0, utils_js_1.getGlobalObject)('runtime/renderPage/isNewEr
 });
 function isNewError(errErrorPage, errNominalPage) {
     (0, utils_js_1.warnIfErrorIsNotObject)(errErrorPage);
-    return !(0, utils_js_1.isSameErrorMessage)(errNominalPage, errErrorPage) || !hasAlreadyLogged(errNominalPage);
+    return (!(0, utils_js_1.isSameErrorMessage)(errNominalPage, errErrorPage) ||
+        // Isn't this redudant/superfluous? I think we can remove this entire file and only use isSameErrorMessage() instead.
+        !hasAlreadyLogged(errNominalPage));
 }
 exports.isNewError = isNewError;
 function hasAlreadyLogged(err) {

package/dist/cjs/node/runtime/renderPage/renderPageAlreadyRouted.js

@@ -22,7 +22,7 @@ const executeGuardHook_js_1 = require("../../../shared/route/executeGuardHook.js
 const loadPageRoutes_js_1 = require("../../../shared/route/loadPageRoutes.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const helpers_js_1 = require("../../../shared/page-configs/helpers.js");
-const isRenderFailure_js_1 = require("../../../shared/misc/isRenderFailure.js");
+const isServerSideError_js_1 = require("../../../shared/misc/isServerSideError.js");
 async function renderPageAlreadyRouted(pageContext) {
     // pageContext._pageId can either be the:
     //  - ID of the page matching the routing, or the
@@ -49,7 +49,7 @@ async function renderPageAlreadyRouted(pageContext) {
     }
     if (pageContext.isClientSideNavigation) {
         if (isError) {
-            (0, utils_js_1.objectAssign)(pageContext, { [isRenderFailure_js_1.isRenderFailure]: true });
+            (0, utils_js_1.objectAssign)(pageContext, { [isServerSideError_js_1.isServerSideError]: true });
         }
         const pageContextSerialized = (0, serializePageContextClientSide_js_1.serializePageContextClientSide)(pageContext);
         const httpResponse = await (0, createHttpResponseObject_js_1.createHttpResponsePageContextJson)(pageContextSerialized);
@@ -187,5 +187,5 @@ function assertV1Design(pageFilesAll, pageConfigs) {
             ...pageFilesAll.map((p) => indent + p.filePath)
         ].join('\n'));
     }
-    (0, utils_js_1.assertWarning)(!isDesignOld, 'You are using the old deprecated design, update to the new V1 design, see https://vike.dev/migration/v1-design', { onlyOnce: true });
+    (0, utils_js_1.assertWarning)(!isDesignOld, "You are using Vike's deprecated design. Update to the new V1 design, see https://vike.dev/migration/v1-design for how to migrate.", { onlyOnce: true });
 }

package/dist/cjs/shared/misc/isServerSideError.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isServerSideError = void 0;
+exports.isServerSideError = '_isServerSideError';

package/dist/cjs/utils/projectInfo.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PROJECT_VERSION = exports.projectInfo = void 0;
 const assertSingleInstance_js_1 = require("./assertSingleInstance.js");
-const PROJECT_VERSION = '0.4.156-commit-d07fbe8';
+const PROJECT_VERSION = '0.4.156-commit-e46716d';
 exports.PROJECT_VERSION = PROJECT_VERSION;
 const projectInfo = {
     projectName: 'Vike',

package/dist/esm/client/client-routing-runtime/getPageContextFromHooks.d.ts

@@ -1,7 +1,6 @@
 export { getPageContextFromHooks_isHydration };
 export { getPageContextFromHooks_isNotHydration };
 export { getPageContextFromHooks_serialized };
-export { isServerSideRouted };
 import type { PageContextExports, PageFile } from '../../shared/getPageFiles.js';
 import type { PageConfigRuntime } from '../../shared/page-configs/PageConfig.js';
 type PageContext = {
@@ -22,13 +21,15 @@ declare function getPageContextFromHooks_isHydration(pageContext: PageContextSer
 }>;
 declare function getPageContextFromHooks_isNotHydration(pageContext: {
     _pageId: string;
-} & PageContext & PageContextExports, isErrorPage: boolean): Promise<(Record<string, unknown> & Record<"_pageId", string> & Record<"is404", boolean> & Record<"pageProps", Record<string, unknown>> & {
-    _hasPageContextFromServer: true;
-    _hasPageContextFromClient: false;
-}) | ({
-    isHydration: false;
-    _hasPageContextFromClient: boolean;
-} & {
-    _hasPageContextFromServer: boolean;
-})>;
-declare function isServerSideRouted(err: unknown): boolean;
+} & PageContext & PageContextExports, isErrorPage: boolean): Promise<{
+    is404ServerSideRouted: boolean;
+    pageContextFromHooks?: undefined;
+} | {
+    pageContextFromHooks: {
+        isHydration: false;
+        _hasPageContextFromClient: boolean;
+    } & {
+        _hasPageContextFromServer: boolean;
+    };
+    is404ServerSideRouted?: undefined;
+}>;

package/dist/esm/client/client-routing-runtime/getPageContextFromHooks.js

@@ -1,7 +1,6 @@
 export { getPageContextFromHooks_isHydration };
 export { getPageContextFromHooks_isNotHydration };
 export { getPageContextFromHooks_serialized };
-export { isServerSideRouted };
 import { assert, assertUsage, hasProp, objectAssign, getProjectError, serverSideRouteTo, executeHook, isObject, getGlobalObject } from './utils.js';
 import { parse } from '@brillout/json-serializer/parse';
 import { getPageContextSerializedInHtml } from '../shared/getPageContextSerializedInHtml.js';
@@ -15,7 +14,7 @@ import { assertOnBeforeRenderHookReturn } from '../../shared/assertOnBeforeRende
 import { executeGuardHook } from '../../shared/route/executeGuardHook.js';
 import { AbortRender, isAbortPageContext } from '../../shared/route/abort.js';
 import { pageContextInitIsPassedToClient } from '../../shared/misc/pageContextInitIsPassedToClient.js';
-import { isRenderFailure } from '../../shared/misc/isRenderFailure.js';
+import { isServerSideError } from '../../shared/misc/isServerSideError.js';
 const globalObject = getGlobalObject('router/getPageContext.ts', {});
 function getPageContextFromHooks_serialized() {
     const pageContextSerialized = getPageContextSerializedInHtml();
@@ -54,23 +53,15 @@ async function getPageContextFromHooks_isNotHydration(pageContext, isErrorPage)
     !isErrorPage &&
         // true if pageContextInit has some client data or at least one of the data() and onBeforeRender() hooks is server-side only:
         (await hasPageContextServer({ ...pageContext, ...pageContextFromHooks }))) {
-        const pageContextFromServer = await fetchPageContextFromServer(pageContext);
+        const res = await fetchPageContextFromServer(pageContext);
+        if ('is404ServerSideRouted' in res)
+            return { is404ServerSideRouted: true };
+        const { pageContextFromServer } = res;
         hasPageContextFromServer = true;
-        if (!pageContextFromServer[isRenderFailure] || isErrorPage) {
-            objectAssign(pageContextFromHooks, pageContextFromServer);
-        }
-        else {
-            // When the user hasn't define a `_error.page.js` file: the mechanism with `serverSideError: true` is used instead
-            assert(!('serverSideError' in pageContextFromServer));
-            assert(hasProp(pageContextFromServer, 'is404', 'boolean'));
-            assert(hasProp(pageContextFromServer, 'pageProps', 'object'));
-            assert(hasProp(pageContextFromServer.pageProps, 'is404', 'boolean'));
-            objectAssign(pageContextFromServer, {
-                _hasPageContextFromServer: true,
-                _hasPageContextFromClient: false
-            });
-            return pageContextFromServer;
-        }
+        // Already handled
+        assert(!(isServerSideError in pageContextFromServer));
+        assert(!('serverSideError' in pageContextFromServer));
+        objectAssign(pageContextFromHooks, pageContextFromServer);
     }
     // At this point, we need to call the client-side guard(), data() and onBeforeRender() hooks, if they exist on client
     // env. However if we have fetched pageContext from the server, some of them might have run already on the
@@ -107,7 +98,7 @@ async function getPageContextFromHooks_isNotHydration(pageContext, isErrorPage)
     objectAssign(pageContextFromHooks, {
         _hasPageContextFromServer: hasPageContextFromServer
     });
-    return pageContextFromHooks;
+    return { pageContextFromHooks };
 }
 async function executeHookClientSide(hookName, pageContext) {
     const hook = getHook(pageContext, hookName);
@@ -217,32 +208,25 @@ async function fetchPageContextFromServer(pageContext) {
         // Static hosts + page doesn't exist
         if (!isCorrect && response.status === 404) {
             serverSideRouteTo(pageContext.urlOriginal);
-            throw ServerSideRouted();
+            return { is404ServerSideRouted: true };
         }
         assertUsage(isCorrect, `Wrong Content-Type for ${pageContextUrl}: it should be ${contentTypeCorrect} but it's ${contentType} instead. Make sure to properly use pageContext.httpResponse.headers, see https://vike.dev/renderPage`);
     }
     const responseText = await response.text();
     const pageContextFromServer = parse(responseText);
     assert(isObject(pageContextFromServer));
-    if ('serverSideError' in pageContextFromServer) {
-        throw getProjectError(`The pageContext object couldn't be fetched from the server as an error occurred on the server-side. Check your server logs.`);
-    }
     if (isAbortPageContext(pageContextFromServer)) {
         throw AbortRender(pageContextFromServer);
     }
+    // Is there a reason for having two different properties? Can't we use only one property? I guess/think the isServerSideError property was an attempt (a bad idea really) for rendering the error page even though an error occured on the server-side (which is a bad idea because the added complexity is non-negligible while the added value is minuscule since the error page usually doesn't have any (meaningful / server-side) hooks).
+    if ('serverSideError' in pageContextFromServer || isServerSideError in pageContextFromServer) {
+        throw getProjectError(`The pageContext object couldn't be fetched from the server as an error occurred on the server-side. Check your server logs.`);
+    }
     assert(hasProp(pageContextFromServer, '_pageId', 'string'));
     processPageContextFromServer(pageContextFromServer);
-    return pageContextFromServer;
+    return { pageContextFromServer };
 }
 function processPageContextFromServer(pageContextFromServer) {
     setPageContextInitIsPassedToClient(pageContextFromServer);
     removeBuiltInOverrides(pageContextFromServer);
 }
-function isServerSideRouted(err) {
-    return isObject(err) && !!err._alreadyServerSideRouted;
-}
-function ServerSideRouted() {
-    const err = new Error("Page doesn't exist");
-    Object.assign(err, { _alreadyServerSideRouted: true });
-    return err;
-}

package/dist/esm/client/client-routing-runtime/renderPageClientSide.js

@@ -2,7 +2,7 @@ export { renderPageClientSide };
 export { getRenderCount };
 export { disableClientRouting };
 import { assert, getCurrentUrl, isSameErrorMessage, objectAssign, serverSideRouteTo, getGlobalObject, executeHook, hasProp } from './utils.js';
-import { getPageContextFromHooks_isHydration, getPageContextFromHooks_isNotHydration, getPageContextFromHooks_serialized, isServerSideRouted } from './getPageContextFromHooks.js';
+import { getPageContextFromHooks_isHydration, getPageContextFromHooks_isNotHydration, getPageContextFromHooks_serialized } from './getPageContextFromHooks.js';
 import { createPageContext } from './createPageContext.js';
 import { addLinkPrefetchHandlers } from './prefetch.js';
 import { assertInfo, assertWarning, isReact } from './utils.js';
@@ -17,7 +17,6 @@ import { setScrollPosition } from './setScrollPosition.js';
 import { updateState } from './onBrowserHistoryNavigation.js';
 import { browserNativeScrollRestoration_disable, setInitialRenderIsDone } from './scrollRestoration.js';
 import { getErrorPageId } from '../../shared/error-page.js';
-import { isRenderFailure } from '../../shared/misc/isRenderFailure.js';
 const globalObject = getGlobalObject('renderPageClientSide.ts', { renderCounter: 0 });
 async function renderPageClientSide(renderArgs) {
     const { scrollTarget, urlOriginal = getCurrentUrl(), overwriteLastHistoryEntry = false, isBackwardNavigation, pageContextsFromRewrite = [], redirectCount = 0, isUserLandPushStateNavigation, isClientSideNavigation = true } = renderArgs;
@@ -32,6 +31,9 @@ async function renderPageClientSide(renderArgs) {
     await renderPageNominal();
     return;
     async function renderPageNominal() {
+        const onError = async (err) => {
+            await renderErrorPage({ err });
+        };
         const pageContext = await getPageContextBegin();
         if (isRenderOutdated())
             return;
@@ -47,7 +49,7 @@ async function renderPageClientSide(renderArgs) {
                 pageContextFromRoute = await route(pageContext);
             }
             catch (err) {
-                await renderErrorPage({ err });
+                await onError(err);
                 return;
             }
             if (isRenderOutdated())
@@ -85,7 +87,9 @@ async function renderPageClientSide(renderArgs) {
                 return;
             }
             else {
-                throw err;
+                // A user file has a syntax error
+                await onError(err);
+                return;
             }
         }
         if (isRenderOutdated())
@@ -113,7 +117,7 @@ async function renderPageClientSide(renderArgs) {
                         await executeHook(() => hookFn(pageContext), hook);
                     }
                     catch (err) {
-                        await renderErrorPage({ err });
+                        await onError(err);
                         return;
                     }
                     if (isRenderOutdated())
@@ -129,7 +133,7 @@ async function renderPageClientSide(renderArgs) {
                 pageContextFromHooks = await getPageContextFromHooks_isHydration(pageContext);
             }
             catch (err) {
-                await renderErrorPage({ err });
+                await onError(err);
                 return;
             }
             if (isRenderOutdated())
@@ -140,20 +144,19 @@ async function renderPageClientSide(renderArgs) {
             await renderPageView(pageContext);
         }
         else {
-            let pageContextFromHooks;
+            let res;
             try {
-                pageContextFromHooks = await getPageContextFromHooks_isNotHydration(pageContext, false);
+                res = await getPageContextFromHooks_isNotHydration(pageContext, false);
             }
             catch (err) {
-                await renderErrorPage({ err });
+                await onError(err);
                 return;
             }
             if (isRenderOutdated())
                 return;
-            if (isRenderFailure in pageContextFromHooks) {
-                await renderErrorPage({ pageContextError: pageContextFromHooks });
+            if ('is404ServerSideRouted' in res)
                 return;
-            }
+            const pageContextFromHooks = res.pageContextFromHooks;
             assert(!('urlOriginal' in pageContextFromHooks));
             objectAssign(pageContext, pageContextFromHooks);
             // Render page view
@@ -174,19 +177,19 @@ async function renderPageClientSide(renderArgs) {
         return pageContext;
     }
     async function renderErrorPage(args) {
-        const pageContext = await getPageContextBegin();
-        if (isRenderOutdated())
-            return;
-        if (args.pageContextError) {
-            objectAssign(pageContext, args.pageContextError);
-        }
+        const onError = (err) => {
+            if (!isSameErrorMessage(err, args.err)) {
+                /* When we can't render the error page, we prefer showing a blank page over letting the server-side try because otherwise:
+                   - We risk running into an infinite loop of reloads which would overload the server.
+                   - An infinite reloading page is a even worse UX than a blank page.
+                serverSideRouteTo(urlOriginal)
+                */
+                console.error(err);
+            }
+        };
         if ('err' in args) {
             const { err } = args;
             assert(err);
-            assert(!('errorWhileRendering' in pageContext));
-            pageContext.errorWhileRendering = err;
-            if (shouldSwallowAndInterrupt(err))
-                return;
             if (!isAbortError(err)) {
                 // We don't swallow 404 errors:
                 //  - On the server-side, Vike swallows / doesn't show any 404 error log because it's expected that a user may go to some random non-existent URL. (We don't want to flood the app's error tracking with 404 logs.)
@@ -197,6 +200,17 @@ async function renderPageClientSide(renderArgs) {
                 // We swallow throw redirect()/render() called by client-side hooks onBeforeRender()/data()/guard()
                 // We handle the abort error down below.
             }
+        }
+        const pageContext = await getPageContextBegin();
+        if (isRenderOutdated())
+            return;
+        if (args.pageContextError) {
+            objectAssign(pageContext, args.pageContextError);
+        }
+        if ('err' in args) {
+            const { err } = args;
+            assert(!('errorWhileRendering' in pageContext));
+            pageContext.errorWhileRendering = err;
             if (isAbortError(err)) {
                 const errAbort = err;
                 logAbortErrorHandled(err, !import.meta.env.DEV, pageContext);
@@ -256,38 +270,44 @@ async function renderPageClientSide(renderArgs) {
                 return;
             }
             else {
-                throw err;
+                // A user file has a syntax error
+                onError(err);
+                return;
             }
         }
         if (isRenderOutdated())
             return;
-        let pageContextFromHooks;
+        let res;
         try {
-            pageContextFromHooks = await getPageContextFromHooks_isNotHydration(pageContext, true);
+            res = await getPageContextFromHooks_isNotHydration(pageContext, true);
         }
-        catch (errErrorPage) {
+        catch (err) {
             // - When user hasn't defined a `_error.page.js` file
             // - Some Vike unpexected internal error
-            if (shouldSwallowAndInterrupt(errErrorPage))
-                return;
-            if (!isSameErrorMessage(args.err, errErrorPage)) {
-                /* When we can't render the error page, we prefer showing a blank page over letting the server-side try because otherwise:
-                   - We risk running into an infinite loop of reloads which would overload the server.
-                   - An infinite reloading page is a even worse UX than a blank page.
-                serverSideRouteTo(urlOriginal)
-                */
-                console.error(errErrorPage);
-            }
+            onError(err);
             return;
         }
         if (isRenderOutdated())
             return;
+        if ('is404ServerSideRouted' in res)
+            return;
+        const pageContextFromHooks = res.pageContextFromHooks;
         assert(pageContextFromHooks);
         assert(!('urlOriginal' in pageContextFromHooks));
         objectAssign(pageContext, pageContextFromHooks);
-        await renderPageView(pageContext, true);
+        await renderPageView(pageContext, args);
     }
     async function renderPageView(pageContext, isErrorPage) {
+        const onError = async (err) => {
+            if (!isErrorPage) {
+                await renderErrorPage({ err });
+            }
+            else {
+                if (!isSameErrorMessage(err, isErrorPage.err)) {
+                    console.error(err);
+                }
+            }
+        };
         // We use globalObject.renderPromise in order to ensure that there is never two concurrent onRenderClient() calls
         if (globalObject.renderPromise) {
             // Make sure that the previous render has finished
@@ -304,12 +324,8 @@ async function renderPageClientSide(renderArgs) {
                 await executeOnRenderClientHook(pageContext, true);
             }
             catch (err) {
-                if (!isErrorPage) {
-                    renderErrorPage({ err });
-                }
-                else {
-                    throw err;
-                }
+                await onError(err);
+                return;
             }
             addLinkPrefetchHandlers(pageContext);
             globalObject.renderPromise = undefined;
@@ -329,12 +345,9 @@ async function renderPageClientSide(renderArgs) {
                     await executeHook(() => hookFn(pageContext), hook);
                 }
                 catch (err) {
-                    if (!isErrorPage) {
-                        renderErrorPage({ err });
-                    }
-                    else {
-                        throw err;
-                    }
+                    await onError(err);
+                    if (!isErrorPage)
+                        return;
                 }
                 if (isRenderOutdated(true))
                     return;
@@ -354,12 +367,9 @@ async function renderPageClientSide(renderArgs) {
                     await executeHook(() => hookFn(pageContext), hook);
                 }
                 catch (err) {
-                    if (!isErrorPage) {
-                        renderErrorPage({ err });
-                    }
-                    else {
-                        throw err;
-                    }
+                    await onError(err);
+                    if (!isErrorPage)
+                        return;
                 }
                 if (isRenderOutdated(true))
                     return;
@@ -378,11 +388,6 @@ function changeUrl(url, overwriteLastHistoryEntry) {
     pushHistory(url, overwriteLastHistoryEntry);
     updateState();
 }
-function shouldSwallowAndInterrupt(err) {
-    if (isServerSideRouted(err))
-        return true;
-    return false;
-}
 function handleErrorFetchingStaticAssets(err, pageContext, isHydrationRender) {
     if (!isErrorFetchingStaticAssets(err)) {
         return false;

package/dist/esm/client/shared/loadUserFilesClientSide.js

@@ -19,10 +19,12 @@ async function loadUserFilesClientSide(pageId, pageFilesAll, pageConfigs) {
         pageConfigLoaded = result[0];
     }
     catch (err) {
-        // To trigger this catch: add `throw new Error()` in the global scope of +onRenderClient.js
         if (isFetchError(err)) {
             Object.assign(err, { [stamp]: true });
         }
+        else {
+            // A user file has a syntax error
+        }
         throw err;
     }
     const { config, configEntries, exports, exportsAll, pageExports } = getExports(pageFilesClientSide, pageConfigLoaded);

package/dist/esm/node/plugin/plugins/commonConfig.js

@@ -1,5 +1,4 @@
 export { commonConfig };
-import { version } from 'vite';
 import { assert, assertWarning, findUserPackageJsonPath } from '../utils.js';
 import { assertRollupInput } from './buildConfig.js';
 import { installRequireShim_setUserRootDir } from '@brillout/require-shim';
@@ -25,7 +24,9 @@ function commonConfig() {
                 order: 'post',
                 handler(config) {
                     overrideViteDefaultPort(config);
-                    overrideViteDefaultSsrExternal(config);
+                    /* TODO: do this after implementing vike.config.js and new setting transformLinkedDependencies (or probably a better name like transpileLinkedDependencies/bundleLinkedDependencies or something else)
+                    overrideViteDefaultSsrExternal(config)
+                    */
                     workaroundCI(config);
                     assertRollupInput(config);
                     assertResolveAlias(config);
@@ -44,13 +45,22 @@ function overrideViteDefaultPort(config) {
     config.preview ?? (config.preview = {});
     (_b = config.preview).port ?? (_b.port = 3000);
 }
-function overrideViteDefaultSsrExternal(config) {
-    var _a;
-    if (!isViteVersionWithSsrExternalTrue())
-        return;
-    // @ts-ignore Not released yet: https://github.com/vitejs/vite/pull/10939/files#diff-5a3d42620df2c6b17e25f440ffdb67683dee7ef57317674d19f41d5f30502310L5
-    (_a = config.ssr).external ?? (_a.external = true);
+/*
+function overrideViteDefaultSsrExternal(config: ResolvedConfig) {
+  if (!isViteVersionWithSsrExternalTrue()) return
+  // @ts-ignore Not released yet: https://github.com/vitejs/vite/pull/10939/files#diff-5a3d42620df2c6b17e25f440ffdb67683dee7ef57317674d19f41d5f30502310L5
+  config.ssr.external ??= true
+}
+import { version } from 'vite'
+function isViteVersionWithSsrExternalTrue(): boolean {
+  const versionParts = version.split('.').map((s) => parseInt(s, 10)) as [number, number, number]
+  assert(versionParts.length === 3)
+  if (versionParts[0] > 5) return true
+  if (versionParts[1] > 0) return true
+  if (versionParts[2] >= 12) return true
+  return false
 }
+*/
 // Workaround GitHub Action failing to access the server
 function workaroundCI(config) {
     var _a, _b;
@@ -73,14 +83,3 @@ function assertEsm(userViteRoot) {
     dir = pc.dim(dir);
     assertWarning(packageJson.type === 'module', `We recommend setting ${dir}package.json#type to "module", see https://vike.dev/CJS`, { onlyOnce: true });
 }
-function isViteVersionWithSsrExternalTrue() {
-    const versionParts = version.split('.').map((s) => parseInt(s, 10));
-    assert(versionParts.length === 3);
-    if (versionParts[0] > 5)
-        return true;
-    if (versionParts[1] > 0)
-        return true;
-    if (versionParts[2] >= 12)
-        return true;
-    return false;
-}

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/crawlPlusFiles.js

@@ -139,6 +139,8 @@ async function isGitMissing(userRootDir) {
 }
 async function runCmd(cmd, cwd) {
     const res = await execA(cmd, { cwd });
-    assert(res.stderr === '');
+    /* Not always true: https://github.com/vikejs/vike/issues/1440#issuecomment-1892831303
+    assert(res.stderr === '')
+    */
     return res.stdout.toString().split('\n').filter(Boolean);
 }

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig.js

@@ -836,6 +836,7 @@ function getConfigName(filePath) {
     }
     else {
         const configName = basename.slice(1);
+        assertUsage(configName !== '', `${filePath} Invalid filename ${fileName}`);
         return configName;
     }
 }
@@ -1028,6 +1029,7 @@ function resolveImportPath(importData, importerFilePath) {
     const importerFilePathAbsolute = importerFilePath.filePathAbsoluteFilesystem;
     assertPosixPath(importerFilePathAbsolute);
     const cwd = path.posix.dirname(importerFilePathAbsolute);
+    // We can't use import.meta.resolve() as of Junary 2023 (and probably for a lot longer): https://stackoverflow.com/questions/54977743/do-require-resolve-for-es-modules#comment137174954_62272600:~:text=But%20the%20argument%20parent%20(aka%20cwd)%20still%20requires%20a%20flag
     // filePathAbsoluteFilesystem is expected to be null when importData.importPath is a Vite path alias
     const filePathAbsoluteFilesystem = requireResolve(importData.importPath, cwd);
     return filePathAbsoluteFilesystem;

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVirtualFilePageConfigs.js

@@ -49,6 +49,8 @@ function getCodePageConfigsSerialized(pageConfigs, isForClientSide, isClientRout
             assert(configValueSource);
             if (!configValueSource.configEnv.eager)
                 return;
+            if (!isRuntimeEnvMatch(configValueSource.configEnv, { isForClientSide, isClientRouting, isEager: true }))
+                return;
             lines.push(...serializeConfigValueImported(configValueSource, configName, whitespace, varCounterContainer, importStatements));
         });
         lines.push(`${whitespace}],`);

package/dist/esm/node/prerender/runPrerender.js

@@ -29,6 +29,8 @@ import { getVikeConfig } from '../plugin/plugins/importUserCode/v1-design/getVik
 import { logHintForCjsEsmError } from '../runtime/renderPage/logHintForCjsEsmError.js';
 async function runPrerenderFromAPI(options = {}) {
     await runPrerender(options, 'prerender()');
+    // - We purposely propagate the error to the user land, so that the error interrupts the user land. It's also, I guess, a nice-to-have that the user has control over the error.
+    // - We don't use logHintForCjsEsmError() because we don't have control over what happens with the error. For example, if the user land purposely swallows the error then the hint shouldn't be logged. Also, it's best if the hint is shown to the user *after* the error, but we cannot do/guarentee that.
 }
 async function runPrerenderFromCLI(options) {
     try {

package/dist/esm/node/runtime/html/serializePageContextClientSide.js

@@ -7,7 +7,7 @@ import { addIs404ToPageProps } from '../../../shared/addIs404ToPageProps.js';
 import pc from '@brillout/picocolors';
 import { notSerializable } from '../../../shared/notSerializable.js';
 import { pageContextInitIsPassedToClient } from '../../../shared/misc/pageContextInitIsPassedToClient.js';
-import { isRenderFailure } from '../../../shared/misc/isRenderFailure.js';
+import { isServerSideError } from '../../../shared/misc/isServerSideError.js';
 const PASS_TO_CLIENT = [
     'abortReason',
     '_urlRewrite',
@@ -21,7 +21,7 @@ const PASS_TO_CLIENT = [
     '_pageId',
     'data' // for data() hook
 ];
-const PASS_TO_CLIENT_ERROR_PAGE = ['pageProps', 'is404', isRenderFailure];
+const PASS_TO_CLIENT_ERROR_PAGE = ['pageProps', 'is404', isServerSideError];
 function serializePageContextClientSide(pageContext) {
     const passToClient = getPassToClient(pageContext);
     const pageContextClient = {};

package/dist/esm/node/runtime/renderPage/isNewError.js

@@ -6,7 +6,9 @@ const globalObject = getGlobalObject('runtime/renderPage/isNewError.ts', {
 });
 function isNewError(errErrorPage, errNominalPage) {
     warnIfErrorIsNotObject(errErrorPage);
-    return !isSameErrorMessage(errNominalPage, errErrorPage) || !hasAlreadyLogged(errNominalPage);
+    return (!isSameErrorMessage(errNominalPage, errErrorPage) ||
+        // Isn't this redudant/superfluous? I think we can remove this entire file and only use isSameErrorMessage() instead.
+        !hasAlreadyLogged(errNominalPage));
 }
 function hasAlreadyLogged(err) {
     if (!isObject(err))

package/dist/esm/node/runtime/renderPage/renderPageAlreadyRouted.js

@@ -21,7 +21,7 @@ import { executeGuardHook } from '../../../shared/route/executeGuardHook.js';
 import { loadPageRoutes } from '../../../shared/route/loadPageRoutes.js';
 import pc from '@brillout/picocolors';
 import { getConfigValueFilePathToShowToUser } from '../../../shared/page-configs/helpers.js';
-import { isRenderFailure } from '../../../shared/misc/isRenderFailure.js';
+import { isServerSideError } from '../../../shared/misc/isServerSideError.js';
 async function renderPageAlreadyRouted(pageContext) {
     // pageContext._pageId can either be the:
     //  - ID of the page matching the routing, or the
@@ -48,7 +48,7 @@ async function renderPageAlreadyRouted(pageContext) {
     }
     if (pageContext.isClientSideNavigation) {
         if (isError) {
-            objectAssign(pageContext, { [isRenderFailure]: true });
+            objectAssign(pageContext, { [isServerSideError]: true });
         }
         const pageContextSerialized = serializePageContextClientSide(pageContext);
         const httpResponse = await createHttpResponsePageContextJson(pageContextSerialized);
@@ -181,5 +181,5 @@ function assertV1Design(pageFilesAll, pageConfigs) {
             ...pageFilesAll.map((p) => indent + p.filePath)
         ].join('\n'));
     }
-    assertWarning(!isDesignOld, 'You are using the old deprecated design, update to the new V1 design, see https://vike.dev/migration/v1-design', { onlyOnce: true });
+    assertWarning(!isDesignOld, "You are using Vike's deprecated design. Update to the new V1 design, see https://vike.dev/migration/v1-design for how to migrate.", { onlyOnce: true });
 }

package/dist/esm/shared/misc/isServerSideError.d.ts

@@ -0,0 +1 @@
+export declare const isServerSideError = "_isServerSideError";

package/dist/esm/shared/misc/isServerSideError.js

@@ -0,0 +1 @@
+export const isServerSideError = '_isServerSideError';

package/dist/esm/shared/page-configs/Config.d.ts

@@ -46,12 +46,12 @@ type Config = ConfigBuiltIn & Vike.Config & (VikePackages.ConfigVikeReact | Vike
  *
  *  https://vike.dev/data
  */
-type DataAsync<Data> = (pageContext: PageContextServer) => Promise<Data>;
+type DataAsync<Data = unknown> = (pageContext: PageContextServer) => Promise<Data>;
 /** Hook for fetching data.
  *
  *  https://vike.dev/data
  */
-type DataSync<Data> = (pageContext: PageContextServer) => Data;
+type DataSync<Data = unknown> = (pageContext: PageContextServer) => Data;
 /** Protect page(s), e.g. forbid unauthorized access.
  *
  *  https://vike.dev/guard

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

@@ -1,13 +1,13 @@
 export { projectInfo };
 export type { ProjectTag };
 export { PROJECT_VERSION };
-declare const PROJECT_VERSION: "0.4.156-commit-d07fbe8";
+declare const PROJECT_VERSION: "0.4.156-commit-e46716d";
 type PackageName = typeof projectInfo.npmPackageName;
 type ProjectVersion = typeof projectInfo.projectVersion;
 type ProjectTag = `[${PackageName}]` | `[${PackageName}@${ProjectVersion}]`;
 declare const projectInfo: {
     projectName: "Vike";
-    projectVersion: "0.4.156-commit-d07fbe8";
+    projectVersion: "0.4.156-commit-e46716d";
     npmPackageName: "vike";
     githubRepository: "https://github.com/vikejs/vike";
 };

package/dist/esm/utils/projectInfo.js

@@ -1,7 +1,7 @@
 export { projectInfo };
 export { PROJECT_VERSION };
 import { onProjectInfo } from './assertSingleInstance.js';
-const PROJECT_VERSION = '0.4.156-commit-d07fbe8';
+const PROJECT_VERSION = '0.4.156-commit-e46716d';
 const projectInfo = {
     projectName: 'Vike',
     projectVersion: PROJECT_VERSION,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.156-commit-d07fbe8",
+  "version": "0.4.156-commit-e46716d",
   "scripts": {
     "dev": "tsc --watch",
     "build": "rimraf dist/ && pnpm run build:esm && pnpm run build:cjs",

package/dist/cjs/shared/misc/isRenderFailure.js

@@ -1,4 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isRenderFailure = void 0;
-exports.isRenderFailure = '_isRenderFailure';

package/dist/esm/shared/misc/isRenderFailure.d.ts

@@ -1 +0,0 @@
-export declare const isRenderFailure = "_isRenderFailure";

package/dist/esm/shared/misc/isRenderFailure.js

@@ -1 +0,0 @@
-export const isRenderFailure = '_isRenderFailure';