vike 0.4.222-commit-5513d32 → 0.4.222-commit-fab3841

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

@@ -4,6 +4,7 @@ import { assert, assertPosixPath, assertUsage, assertWarning, escapeRegex, isArr
 import { sourceMapPassthrough } from '../shared/rollupSourceMap.js';
 import { getModuleFilePathAbsolute } from '../shared/getFilePath.js';
 import { normalizeId } from '../shared/normalizeId.js';
+import { viteIsSSR_safe } from '../shared/viteIsSSR.js';
 // TODO/enventually: (after we implemented vike.config.js)
 // - Make import.meta.env work inside +config.js
 //   - For it to work, we'll probably need the user to define the settings (e.g. `envDir`) for loadEnv() inside vike.config.js instead of vite.config.js
@@ -36,7 +37,7 @@ function envVarsPlugin() {
             if (!code.includes('import.meta.env.'))
                 return;
             const isBuild = config.command === 'build';
-            const isClientSide = getIsClientSide(config, options);
+            const isClientSide = !viteIsSSR_safe(config, options);
             Object.entries(envsAll)
                 .filter(([key]) => {
                 // Already handled by Vite
@@ -82,19 +83,3 @@ function envVarsPlugin() {
 function applyEnvVar(envStatementRegEx, envVal, code) {
     return code.replace(envStatementRegEx, JSON.stringify(envVal));
 }
-function getIsClientSide(config, options) {
-    const isBuild = config.command === 'build';
-    if (isBuild) {
-        assert(typeof config.build.ssr === 'boolean');
-        const isServerSide = config.build.ssr;
-        if (options !== undefined) {
-            assert(options.ssr === isServerSide);
-        }
-        return !isServerSide;
-    }
-    else {
-        assert(typeof options?.ssr === 'boolean');
-        const isServerSide = options.ssr;
-        return !isServerSide;
-    }
-}

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

@@ -17,7 +17,7 @@ import { fixServerAssets_isEnabled } from './buildConfig/fixServerAssets.js';
 import { getVikeConfig, isV1Design } from './importUserCode/v1-design/getVikeConfig.js';
 import { assertV1Design } from '../../shared/assertV1Design.js';
 import { normalizeId } from '../shared/normalizeId.js';
-import { viteIsSSR_options } from '../shared/viteIsSSR.js';
+import { viteIsSSR_safe } from '../shared/viteIsSSR.js';
 const extractAssetsRE = /(\?|&)extractAssets(?:&|$)/;
 const rawRE = /(\?|&)raw(?:&|$)/;
 const urlRE = /(\?|&)url(?:&|$)/;
@@ -46,7 +46,7 @@ function extractAssetsPlugin() {
                 }
                 // TODO/now: add meta.default
                 assert(vikeConfig.global.config.includeAssetsImportedByServer ?? true);
-                assert(!viteIsSSR_options(options));
+                assert(!viteIsSSR_safe(config, options));
                 const importStatements = await getImportStatements(src);
                 const moduleNames = getImportedModules(importStatements);
                 const code = moduleNames.map((moduleName) => `import '${moduleName}';`).join('\n');
@@ -63,7 +63,7 @@ function extractAssetsPlugin() {
             //  - Vite's `vite:resolve` plugin; https://github.com/vitejs/vite/blob/d649daba7682791178b711d9a3e44a6b5d00990c/packages/vite/src/node/plugins/resolve.ts#L105
             enforce: 'pre',
             async resolveId(source, importer, options) {
-                if (viteIsSSR_options(options)) {
+                if (viteIsSSR_safe(config, options)) {
                     // When building for the server, there should never be a `?extractAssets` query
                     assert(!extractAssetsRE.test(source));
                     assert(importer === undefined || !extractAssetsRE.test(importer));

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

@@ -8,7 +8,7 @@ import { normalizeId } from '../shared/normalizeId.js';
 import { viteIsSSR_options } from '../shared/viteIsSSR.js';
 const extractExportNamesRE = /(\?|&)extractExportNames(?:&|$)/;
 const debug = createDebugger('vike:extractExportNames');
-const globalObject = getGlobalObject('extractExportNamesPlugin.ts', {});
+const globalObject = getGlobalObject('plugins/extractExportNamesPlugin.ts', {});
 function extractExportNamesPlugin() {
     let isDev = false;
     return {

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

@@ -11,7 +11,7 @@ import { getEnvVarObject } from '../../../../shared/getEnvVarObject.js';
 const execA = promisify(exec);
 const debug = createDebugger('vike:crawl');
 assertIsNotProductionRuntime();
-assertIsSingleModuleInstance('crawlPlusFiles.ts');
+assertIsSingleModuleInstance('getVikeConfig/crawlPlusFiles.ts');
 let gitIsNotUsable = false;
 async function crawlPlusFiles(userRootDir, outDirAbsoluteFilesystem) {
     assertPosixPath(userRootDir);

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

@@ -8,7 +8,7 @@ export { getConfigDefinitionOptional };
 import { assertPosixPath, assert, isObject, assertUsage, assertWarning, objectEntries, hasProp, includes, assertIsNotProductionRuntime, getMostSimilar, joinEnglish, assertKeys, objectKeys, objectFromEntries, unique, isCallable, makeFirst, lowerFirst } from '../../../utils.js';
 import { configDefinitionsBuiltIn } from './getVikeConfig/configDefinitionsBuiltIn.js';
 import { getLocationId, getFilesystemRouteString, getFilesystemRouteDefinedBy, isInherited, sortAfterInheritanceOrder, applyFilesystemRoutingRootEffect } from './getVikeConfig/filesystemRouting.js';
-import { isConfigInvalid, isConfigInvalid_set } from '../../../../runtime/renderPage/isConfigInvalid.js';
+import { isVikeConfigInvalid, isVikeConfigInvalid_set } from '../../../../runtime/renderPage/isVikeConfigInvalid.js';
 import { getViteDevServer } from '../../../../runtime/globalContext.js';
 import { logConfigError, logConfigErrorRecover } from '../../../shared/loggerNotProd.js';
 import { removeSuperfluousViteLog_enable, removeSuperfluousViteLog_disable } from '../../../shared/loggerVite/removeSuperfluousViteLog.js';
@@ -37,7 +37,7 @@ function reloadVikeConfig(config) {
     handleReloadSideEffects();
 }
 async function handleReloadSideEffects() {
-    wasConfigInvalid = !!isConfigInvalid;
+    wasConfigInvalid = !!isVikeConfigInvalid;
     const vikeConfigPromisePrevious = vikeConfigPromise;
     try {
         await vikeConfigPromise;
@@ -52,7 +52,7 @@ async function handleReloadSideEffects() {
         // Let the next handleReloadSideEffects() call handle side effects
         return;
     }
-    if (!isConfigInvalid) {
+    if (!isVikeConfigInvalid) {
         if (wasConfigInvalid) {
             wasConfigInvalid = false;
             logConfigErrorRecover();
@@ -105,13 +105,13 @@ async function loadVikeConfig_withErrorHandling(userRootDir, isDev, vikeVitePlug
     if (!hasError) {
         assert(ret);
         assert(err === undefined);
-        isConfigInvalid_set(false);
+        isVikeConfigInvalid_set(false);
         return ret;
     }
     else {
         assert(ret === undefined);
         assert(err);
-        isConfigInvalid_set({ err });
+        isVikeConfigInvalid_set({ err });
         if (!isDev) {
             assert(getViteDevServer() === null);
             throw err;

package/dist/esm/node/plugin/shared/viteIsSSR.d.ts

@@ -1,8 +1,11 @@
-import type { ResolvedConfig, UserConfig } from 'vite';
 export { viteIsSSR };
 export { viteIsSSR_options };
+export { viteIsSSR_safe };
+import type { ResolvedConfig, UserConfig } from 'vite';
 declare function viteIsSSR(config: ResolvedConfig | UserConfig): boolean;
-type Options = undefined | boolean | {
+declare function viteIsSSR_options(options: {
+    ssr?: boolean;
+} | undefined): boolean;
+declare function viteIsSSR_safe(config: ResolvedConfig, options: {
     ssr?: boolean;
-};
-declare function viteIsSSR_options(options: Options): boolean;
+} | undefined): boolean;

package/dist/esm/node/plugin/shared/viteIsSSR.js

@@ -1,20 +1,29 @@
-import { assert } from '../../../utils/assert.js';
-import { isObject } from '../../../utils/isObject.js';
 export { viteIsSSR };
 export { viteIsSSR_options };
+export { viteIsSSR_safe };
+import { assert } from '../../../utils/assert.js';
 function viteIsSSR(config) {
     return !!config?.build?.ssr;
 }
-// https://github.com/vitejs/vite/discussions/5109#discussioncomment-1450726
 function viteIsSSR_options(options) {
-    if (options === undefined) {
-        return false;
-    }
-    if (typeof options === 'boolean') {
-        return options;
+    return !!options?.ssr;
+}
+// Vite is quite messy about setting `ssr: boolean`, thus we use an extra safe implemention for security purposes.
+// It's used for .client.js and .server.js guarantee thus we use agressive assert() calls for added safety.
+function viteIsSSR_safe(config, options) {
+    if (config.command === 'build') {
+        assert(typeof config.build.ssr === 'boolean');
+        const val = config.build.ssr;
+        if (options?.ssr !== undefined)
+            assert(val === options.ssr);
+        return val;
     }
-    if (isObject(options)) {
-        return !!options.ssr;
+    else {
+        assert(typeof options?.ssr === 'boolean');
+        const val = options.ssr;
+        /* This assert() fails (which is very unexpected).
+        if (typeof config.build.ssr === 'boolean') assert(val === config.build.ssr)
+        //*/
+        return val;
     }
-    assert(false);
 }

package/dist/esm/node/runtime/globalContext.js

@@ -34,7 +34,7 @@ import { assertV1Design } from '../shared/assertV1Design.js';
 import { getPageConfigsRuntime } from '../../shared/getPageConfigsRuntime.js';
 import { resolveBase } from '../shared/resolveBase.js';
 const debug = createDebugger('vike:globalContext');
-const globalObject = getGlobalObject('globalContext.ts', getInitialGlobalContext());
+const globalObject = getGlobalObject('runtime/globalContext.ts', getInitialGlobalContext());
 async function getGlobalContextInternal() {
     // getGlobalContextInternal() should always be called after initGlobalContext()
     assert(globalObject.isInitialized);

package/dist/esm/node/runtime/renderPage/createHttpResponse/assertNoInfiniteHttpRedirect.js

@@ -1,7 +1,7 @@
 export { assertNoInfiniteHttpRedirect };
 import { assert, assertUsage, getGlobalObject } from '../../utils.js';
 import pc from '@brillout/picocolors';
-const globalObject = getGlobalObject('assertNoInfiniteHttpRedirect.ts', {
+const globalObject = getGlobalObject('createHttpResponse/assertNoInfiniteHttpRedirect.ts', {
     redirectGraph: {}
 });
 function assertNoInfiniteHttpRedirect(urlRedirectTarget, urlLogical) {

package/dist/esm/node/runtime/renderPage/createHttpResponse.d.ts

@@ -3,6 +3,7 @@ export { createHttpResponsePageContextJson };
 export { createHttpResponseError };
 export { createHttpResponseRedirect };
 export { createHttpResponseFavicon404 };
+export { createHttpResponseBaseIsMissing };
 export type { HttpResponse };
 import type { GetPageAssets } from './getPageAssets.js';
 import type { HtmlRender } from '../html/renderHtml.js';
@@ -28,6 +29,7 @@ declare function createHttpResponsePage(htmlRender: HtmlRender, renderHook: null
     abortStatusCode?: AbortStatusCode;
 }): Promise<HttpResponse>;
 declare function createHttpResponseFavicon404(): HttpResponse;
+declare function createHttpResponseBaseIsMissing(urlOriginal: string, baseServer: string): HttpResponse;
 declare function createHttpResponseError(pageContext: null | {
     _pageFilesAll: PageFile[];
     _pageConfigs: PageConfigRuntime[];

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

@@ -3,6 +3,7 @@ export { createHttpResponsePageContextJson };
 export { createHttpResponseError };
 export { createHttpResponseRedirect };
 export { createHttpResponseFavicon404 };
+export { createHttpResponseBaseIsMissing };
 import { assert, assertWarning, escapeHtml } from '../utils.js';
 import { getErrorPageId, isErrorPage } from '../../../shared/error-page.js';
 import { getHttpResponseBody, getHttpResponseBodyStreamHandlers } from './getHttpResponseBody.js';
@@ -38,6 +39,29 @@ function createHttpResponseFavicon404() {
     const httpResponse = createHttpResponse(404, 'text/html;charset=utf-8', [], "<p>No favicon.ico found.</p><script>console.log('This HTTP response was generated by Vike.')</script>");
     return httpResponse;
 }
+function createHttpResponseBaseIsMissing(urlOriginal, baseServer) {
+    const httpResponse = createHttpResponse(
+    // We use the error code `500` to signal a failing state because this HTTP response should never be used, see https://vike.dev/base-url#setup
+    // In other words: this HTTP response is expected to be generated but isn't expected to be actually used.
+    500, 'text/html;charset=utf-8', [], `
+<h1>Error: Base URL is missing</h1>
+<p>
+  <a href="https://vike.dev/renderPage"><code>renderPage(pageContextInit)</code></a> called with <code>pageContextInit.urlOriginal===${JSON.stringify(urlOriginal)}</code> which doesn't start with the Base URL <code>${baseServer}</code>.
+</p>
+<p>
+  See <a href="https://vike.dev/base-url#setup">vike.dev/base-url#setup</a> for how to properly setup your server while using a Base URL.
+</p>
+<style>
+  code {
+    font-family: monospace;
+    background-color: #eaeaea;
+    padding: 3px 5px;
+    border-radius: 4px;
+  }
+</style>
+`);
+    return httpResponse;
+}
 function createHttpResponseError(pageContext) {
     const reason = (() => {
         if (!pageContext) {

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

@@ -6,7 +6,7 @@ import { retrieveAssetsProd } from './getPageAssets/retrieveAssetsProd.js';
 import { inferMediaType } from './inferMediaType.js';
 import { getManifestEntry } from './getPageAssets/getManifestEntry.js';
 import { sortPageAssetsForEarlyHintsHeader } from './getPageAssets/sortPageAssetsForEarlyHintsHeader.js';
-const globalObject = getGlobalObject('getPageAssets.ts', {
+const globalObject = getGlobalObject('renderPage/getPageAssets.ts', {
     resolveClientEntriesDev: null
 });
 async function getPageAssets(pageContext, clientDependencies, clientEntries) {

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

@@ -1,7 +1,7 @@
 export { handlePageContextRequestUrl };
 import { pageContextJsonFileExtension, doNotCreateExtraDirectory } from '../../../shared/getPageContextRequestUrl.js';
 import { baseServer, parseUrl, assert, slice } from '../utils.js';
-// See shared/getPageContextRequestUrl.ts
+// See also shared/getPageContextRequestUrl.ts
 function handlePageContextRequestUrl(url) {
     if (!hasSuffix(url)) {
         return { urlWithoutPageContextRequestSuffix: url, isPageContextRequest: false };

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

@@ -1,7 +1,7 @@
 export { isNewError };
 export { setAlreadyLogged };
 import { getGlobalObject, isObject, isSameErrorMessage, warnIfErrorIsNotObject } from '../utils.js';
-const globalObject = getGlobalObject('runtime/renderPage/isNewError.ts', {
+const globalObject = getGlobalObject('renderPage/isNewError.ts', {
     wasAlreadyLogged: new WeakSet()
 });
 function isNewError(errErrorPage, errNominalPage) {

package/dist/esm/node/runtime/renderPage/isVikeConfigInvalid.d.ts

@@ -0,0 +1,6 @@
+export { isVikeConfigInvalid };
+export { isVikeConfigInvalid_set };
+declare let isVikeConfigInvalid: false | {
+    err: unknown;
+};
+declare const isVikeConfigInvalid_set: (val: typeof isVikeConfigInvalid) => void;

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

@@ -0,0 +1,8 @@
+export { isVikeConfigInvalid };
+export { isVikeConfigInvalid_set };
+import { assert } from '../utils.js';
+let isVikeConfigInvalid;
+const isVikeConfigInvalid_set = (val) => {
+    assert(val === false || val.err);
+    isVikeConfigInvalid = val;
+};

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

@@ -6,12 +6,12 @@ import { assert, hasProp, objectAssign, isUrl, parseUrl, onSetupRuntime, assertW
 import { assertNoInfiniteAbortLoop, getPageContextFromAllRewrites, isAbortError, logAbortErrorHandled } from '../../shared/route/abort.js';
 import { getGlobalContextInternal, initGlobalContext_renderPage } from './globalContext.js';
 import { handlePageContextRequestUrl } from './renderPage/handlePageContextRequestUrl.js';
-import { createHttpResponseFavicon404, createHttpResponseRedirect, createHttpResponsePageContextJson, createHttpResponseError } from './renderPage/createHttpResponse.js';
+import { createHttpResponseFavicon404, createHttpResponseRedirect, createHttpResponsePageContextJson, createHttpResponseError, createHttpResponseBaseIsMissing } from './renderPage/createHttpResponse.js';
 import { logRuntimeError, logRuntimeInfo } from './renderPage/loggerRuntime.js';
 import { isNewError } from './renderPage/isNewError.js';
 import { assertArguments } from './renderPage/assertArguments.js';
 import { log404 } from './renderPage/log404/index.js';
-import { isConfigInvalid } from './renderPage/isConfigInvalid.js';
+import { isVikeConfigInvalid } from './renderPage/isVikeConfigInvalid.js';
 import pc from '@brillout/picocolors';
 import { serializePageContextAbort, serializePageContextClientSide } from './html/serializePageContextClientSide.js';
 import { getErrorPageId } from '../../shared/error-page.js';
@@ -25,12 +25,11 @@ const globalObject = getGlobalObject('runtime/renderPage.ts', {
 async function renderPage(pageContextInit) {
     assertArguments(...arguments);
     assert(hasProp(pageContextInit, 'urlOriginal', 'string')); // assertUsage() already implemented at assertArguments()
-    onSetupRuntime();
     assertIsUrl(pageContextInit.urlOriginal);
-    const urlPathnameWithBase = parseUrl(pageContextInit.urlOriginal, '/').pathname;
-    assertIsNotViteRequest(urlPathnameWithBase, pageContextInit.urlOriginal);
-    if (urlPathnameWithBase.endsWith('/favicon.ico'))
-        return getPageContextHttpResponseFavicon404(pageContextInit);
+    onSetupRuntime();
+    const pageContextInvalidRequest = renderInvalidRequest(pageContextInit);
+    if (pageContextInvalidRequest)
+        return pageContextInvalidRequest;
     const httpRequestId = getRequestId();
     const urlOriginalPretty = getUrlPretty(pageContextInit.urlOriginal);
     logHttpRequest(urlOriginalPretty, httpRequestId);
@@ -50,15 +49,10 @@ function renderPage_addAsyncHookwrapper(wrapper) {
 }
 async function renderPageAndPrepare(pageContextInit, httpRequestId) {
     // Invalid config
-    const handleInvalidConfig = (err) => {
-        logRuntimeInfo?.(pc.bold(pc.red('Error while loading a Vike config file, see error above.')), httpRequestId, 'error');
-        const pageContextWithError = getPageContextHttpResponseError(err, pageContextInit, null);
-        return pageContextWithError;
-    };
-    if (isConfigInvalid) {
+    if (isVikeConfigInvalid) {
         if (1 < 2 // Make TS happy
         ) {
-            return handleInvalidConfig(isConfigInvalid.err);
+            return renderInvalidVikeConfig(isVikeConfigInvalid.err, pageContextInit, httpRequestId);
         }
     }
     // Prepare context
@@ -76,15 +70,19 @@ async function renderPageAndPrepare(pageContextInit, httpRequestId) {
         const pageContextWithError = getPageContextHttpResponseError(err, pageContextInit, null);
         return pageContextWithError;
     }
-    if (isConfigInvalid) {
-        return handleInvalidConfig(isConfigInvalid.err);
+    if (isVikeConfigInvalid) {
+        return renderInvalidVikeConfig(isVikeConfigInvalid.err, pageContextInit, httpRequestId);
     }
     else {
-        // From now on, globalContext contains all the configuration data; getVikeConfig() isn't called anymore for this request
+        // `globalContext` now contains the entire Vike config and getVikeConfig() isn't called anymore for this request.
     }
     const globalContext = await getGlobalContextInternal();
     // Check Base URL
-    await assertBaseUrl(pageContextInit, globalContext);
+    {
+        const pageContextHttpResponse = await checkBaseUrl(pageContextInit, globalContext);
+        if (pageContextHttpResponse)
+            return pageContextHttpResponse;
+    }
     // Normalize URL
     {
         const pageContextHttpResponse = await normalizeUrl(pageContextInit, globalContext, httpRequestId);
@@ -252,15 +250,6 @@ function getPageContextHttpResponseError(err, pageContextInit, pageContext) {
     });
     return pageContextWithError;
 }
-function getPageContextHttpResponseFavicon404(pageContextInit) {
-    const pageContext = createPageContext(pageContextInit);
-    const httpResponse = createHttpResponseFavicon404();
-    objectAssign(pageContext, {
-        httpResponse
-    });
-    checkType(pageContext);
-    return pageContext;
-}
 function createPageContext(pageContextInit) {
     const pageContext = {
         _isPageContextObject: true
@@ -453,10 +442,35 @@ pageContextNominalPageInit, httpRequestId, pageContextErrorPageInit, globalConte
     assert(pageContextAbort.abortStatusCode);
     return { pageContextAbort };
 }
-async function assertBaseUrl(pageContextInit, globalContext) {
+async function checkBaseUrl(pageContextInit, globalContext) {
     const { baseServer } = globalContext;
     const { urlOriginal } = pageContextInit;
-    const { urlWithoutPageContextRequestSuffix } = handlePageContextRequestUrl(urlOriginal);
-    const { isBaseMissing } = parseUrl(urlWithoutPageContextRequestSuffix, baseServer);
-    assertUsage(!isBaseMissing, `${pc.code('renderPage(pageContextInit)')} (https://vike.dev/renderPage) called with ${pc.code(`pageContextInit.urlOriginal===${JSON.stringify(urlOriginal)}`)} which doesn't start with Base URL ${pc.code(baseServer)} (https://vike.dev/base-url)`);
+    const { isBaseMissing } = parseUrl(urlOriginal, baseServer);
+    if (!isBaseMissing)
+        return;
+    const pageContext = createPageContext(pageContextInit);
+    const httpResponse = createHttpResponseBaseIsMissing(urlOriginal, baseServer);
+    objectAssign(pageContext, {
+        httpResponse,
+        isBaseMissing: true
+    });
+    checkType(pageContext);
+    return pageContext;
+}
+function renderInvalidRequest(pageContextInit) {
+    const urlPathnameWithBase = parseUrl(pageContextInit.urlOriginal, '/').pathname;
+    assertIsNotViteRequest(urlPathnameWithBase, pageContextInit.urlOriginal);
+    if (urlPathnameWithBase.endsWith('/favicon.ico')) {
+        const pageContext = createPageContext(pageContextInit);
+        const httpResponse = createHttpResponseFavicon404();
+        objectAssign(pageContext, { httpResponse });
+        checkType(pageContext);
+        return pageContext;
+    }
+    return null;
+}
+function renderInvalidVikeConfig(err, pageContextInit, httpRequestId) {
+    logRuntimeInfo?.(pc.bold(pc.red('Error while loading a Vike config file, see error above.')), httpRequestId, 'error');
+    const pageContextWithError = getPageContextHttpResponseError(err, pageContextInit, null);
+    return pageContextWithError;
 }

package/dist/esm/shared/getPageContextRequestUrl.js

@@ -6,7 +6,7 @@ import { urlToFile } from '../utils/urlToFile.js';
 const pageContextJsonFileExtension = '.pageContext.json';
 // `/some-base-url/index.pageContext.json` instead of `/some-base-url.pageContext.json` in order to comply to common reverse proxy setups, see https://github.com/vikejs/vike/issues/443
 const doNotCreateExtraDirectory = false;
-// See node/renderPage/handlePageContextRequestUrl.ts
+// See also node/renderPage/handlePageContextRequestUrl.ts
 function getPageContextRequestUrl(url) {
     const pageContextRequestUrl = urlToFile(url, pageContextJsonFileExtension, doNotCreateExtraDirectory);
     return pageContextRequestUrl;

package/dist/esm/shared/getPageContextUrlComputed.js

@@ -37,26 +37,29 @@ function getUrlParsed(pageContext) {
     //  6. The value of pageContext.urlPathname is now '/login': the pathname of `pageContext.urlLogical`. (While pageContext.urlOriginal is still '/fr-FR/admin'.)
     // Reproduction: https://github.com/vikejs/vike/discussions/1436#discussioncomment-8142023
     // Determine logical URL
-    // TODO/soon: revert https://github.com/vikejs/vike/issues/2138#issuecomment-2631713411
-    const assertUrlResolved = (src) => assert(urlResolved && typeof urlResolved === 'string', { src, urlResolved });
+    const assertUrlResolved = (src) => assert(urlResolved && typeof urlResolved === 'string', 
+    // TODO/eventually: remove debug logs, see:
+    // - https://github.com/vikejs/vike/issues/2138#issuecomment-2631713411
+    // - https://github.com/vikejs/vike/commit/5c7810f3080ab62536950f26e019bb2a3a517082
+    { src, urlResolved });
     let urlResolved;
-    let baseToBeRemoved;
+    let isBaseToBeRemoved;
     if (pageContext.urlLogical) {
         // Set by onBeforeRoute()
         urlResolved = pageContext.urlLogical;
-        baseToBeRemoved = false;
+        isBaseToBeRemoved = false;
         assertUrlResolved(1);
     }
     else if (pageContext._urlRewrite) {
         // Set by `throw render()`
         urlResolved = pageContext._urlRewrite;
-        baseToBeRemoved = false;
+        isBaseToBeRemoved = false;
         assertUrlResolved(2);
     }
     else {
         // Set by renderPage()
         urlResolved = pageContext.urlOriginal;
-        baseToBeRemoved = true;
+        isBaseToBeRemoved = true;
         assertUrlResolved(3);
     }
     assertUrlResolved(4);
@@ -69,7 +72,7 @@ function getUrlParsed(pageContext) {
     // - We assume there isn't any Base URL to the URLs set by the user at `throw render()` and onBeforeRoute()
     //   - This makes sense because the Base URL is merely a setting: ideally the user should write code that doesn't know anything about it (so that the user can remove/add/change Base URL without having to modify any code).
     // - pageContext.urlOriginal is the URL of the HTTP request and thus contains the Base URL.
-    const baseServer = !baseToBeRemoved ? '/' : pageContext._baseServer;
+    const baseServer = !isBaseToBeRemoved ? '/' : pageContext._baseServer;
     // Parse URL
     return parseUrl(urlResolved, baseServer);
 }

package/dist/esm/shared/hooks/getHook.js

@@ -11,7 +11,7 @@ import { getHookFilePathToShowToUser } from '../page-configs/helpers.js';
 import { getConfigValueRuntime } from '../page-configs/getConfigValueRuntime.js';
 import { assert, assertUsage, checkType, isCallable, isObject } from '../utils.js';
 import pc from '@brillout/picocolors';
-const globalObject = getGlobalObject('getHook.ts', {});
+const globalObject = getGlobalObject('hooks/getHook.ts', {});
 function getHook(pageContext, hookName) {
     if (!(hookName in pageContext.exports)) {
         return null;

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

@@ -131,6 +131,12 @@ type PageContextBuiltInCommon<Data> = {
     url: string;
     /** @deprecated */
     pageExports: Record<string, unknown>;
+    /**
+     * Whether the Base URL is missing in the URL of the HTTP request made to the SSR server.
+     *
+     * https://vike.dev/base-url#setup
+     */
+    isBaseMissing?: true;
 };
 type PageContextBuiltInServer<Data> = PageContextBuiltInCommon<Data> & PageContextUrlServer;
 type PageContextBuiltInClientWithClientRouting<Data> = Partial<PageContextBuiltInCommon<Data>> & Pick<PageContextBuiltInCommon<Data>, 'Page' | 'routeParams' | 'pageExports' | 'config' | 'configEntries' | 'exports' | 'exportsAll' | 'abortReason' | 'data' | 'pageId' | 'source' | 'sources' | 'from'> & {

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

@@ -1 +1 @@
-export declare const PROJECT_VERSION: "0.4.222-commit-5513d32";
+export declare const PROJECT_VERSION: "0.4.222-commit-fab3841";

package/dist/esm/utils/PROJECT_VERSION.js

@@ -1,2 +1,2 @@
 // Automatically updated by @brillout/release-me
-export const PROJECT_VERSION = '0.4.222-commit-5513d32';
+export const PROJECT_VERSION = '0.4.222-commit-fab3841';

package/dist/esm/utils/assertSetup.js

@@ -16,7 +16,7 @@ import { isVitest } from './isVitest.js';
 import pc from '@brillout/picocolors';
 assertIsNotBrowser();
 const debug = createDebugger('vike:setup');
-const setup = getGlobalObject('utils/assertIsNotProductionRuntime.ts', {});
+const setup = getGlobalObject('utils/assertSetup.ts', {});
 // Called by Vike modules that want to ensure that they aren't loaded by the server runtime in production
 function assertIsNotProductionRuntime() {
     if (debug.isActivated)

package/dist/esm/utils/assertSingleInstance.js

@@ -11,7 +11,7 @@ import pc from '@brillout/picocolors';
 /* Use original assertUsage() & assertWarning() after all CJS is removed from node_modules/vike/dist/
 import { assertUsage, assertWarning } from './assert.js'
 */
-const globalObject = getGlobalObject('assertSingleInstance.ts', {
+const globalObject = getGlobalObject('utils/assertSingleInstance.ts', {
     instances: [],
     alreadyLogged: new Set()
 });

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

@@ -1,6 +1,7 @@
 export { getGlobalObject };
 export { assertIsSingleModuleInstance };
+type Key = `${string}/${string}.ts`;
 /** Share information across module instances. */
-declare function getGlobalObject<T extends Record<string, unknown> = never>(key: `${string}.ts`, defaultValue: T): T;
+declare function getGlobalObject<T extends Record<string, unknown> = never>(key: Key, defaultValue: T): T;
 /** Assert that the module is instantiated only once. */
-declare function assertIsSingleModuleInstance(key: `${string}.ts`): void;
+declare function assertIsSingleModuleInstance(key: Key): void;

package/dist/esm/utils/getGlobalObject.js

@@ -2,17 +2,13 @@ export { getGlobalObject };
 export { assertIsSingleModuleInstance };
 import { assert } from './assert.js';
 /** Share information across module instances. */
-function getGlobalObject(
-// We use the filename (or file path) as key. There should be only one getGlobalObject() usage per file. Thus the key should be unique, assuming the filename (or file path) is unique.
-key, defaultValue) {
+function getGlobalObject(key, defaultValue) {
     const globalObjects = getGlobalObjects();
     const globalObject = (globalObjects[key] = globalObjects[key] || defaultValue);
     return globalObject;
 }
 /** Assert that the module is instantiated only once. */
-function assertIsSingleModuleInstance(
-// We use the filename (or file path) as key.
-key) {
+function assertIsSingleModuleInstance(key) {
     const globalObjects = getGlobalObjects();
     assert(!(key in globalObjects));
 }

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

@@ -1,4 +1,4 @@
 export declare const projectInfo: {
     projectName: "Vike";
-    projectVersion: "0.4.222-commit-5513d32";
+    projectVersion: "0.4.222-commit-fab3841";
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.222-commit-5513d32",
+  "version": "0.4.222-commit-fab3841",
   "repository": "https://github.com/vikejs/vike",
   "exports": {
     "./server": {

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

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isConfigInvalid_set = exports.isConfigInvalid = void 0;
-const utils_js_1 = require("../utils.js");
-let isConfigInvalid;
-const isConfigInvalid_set = (val) => {
-    (0, utils_js_1.assert)(val === false || val.err);
-    exports.isConfigInvalid = isConfigInvalid = val;
-};
-exports.isConfigInvalid_set = isConfigInvalid_set;

package/dist/esm/node/runtime/renderPage/isConfigInvalid.d.ts

@@ -1,6 +0,0 @@
-export { isConfigInvalid };
-export { isConfigInvalid_set };
-declare let isConfigInvalid: false | {
-    err: unknown;
-};
-declare const isConfigInvalid_set: (val: typeof isConfigInvalid) => void;

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

@@ -1,8 +0,0 @@
-export { isConfigInvalid };
-export { isConfigInvalid_set };
-import { assert } from '../utils.js';
-let isConfigInvalid;
-const isConfigInvalid_set = (val) => {
-    assert(val === false || val.err);
-    isConfigInvalid = val;
-};