vike 0.4.224 → 0.4.225

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

@@ -1,23 +1,31 @@
 export { assertNoInfiniteHttpRedirect };
-import { assert, assertUsage, getGlobalObject } from '../../utils.js';
+import { assert, assertUsage, getGlobalObject, removeUrlOrigin } from '../../utils.js';
 import pc from '@brillout/picocolors';
 const globalObject = getGlobalObject('createHttpResponse/assertNoInfiniteHttpRedirect.ts', {
     redirectGraph: {}
 });
-function assertNoInfiniteHttpRedirect(urlRedirectTarget, urlLogical) {
+// It's too strict, see https://github.com/vikejs/vike/issues/1270#issuecomment-1820608999
+// - Let's create a new setting `+doNotCatchInfiniteRedirect` if someone complains.
+function assertNoInfiniteHttpRedirect(
+// The exact URL that the user will be redirected to.
+// - It includes the Base URL as well as the locale (i18n) base.
+urlRedirectTarget, 
+// Rationale for checking against `pageContextInit.urlOriginal`: https://github.com/vikejs/vike/pull/2264#issuecomment-2713890263
+pageContextInit) {
     if (!urlRedirectTarget.startsWith('/')) {
-        // We assume that urlRedirectTarget points to an origin that is external (not the same origin), and we can therefore assume that the app doesn't define an infinite loop (in itself).
-        //  - There isn't a reliable way to check whether the redirect points to an external origin or the same origin. For same origins, we assume/hope the user to pass the URL without origin.
+        // We assume that urlRedirectTarget points to an origin that is external (not the same origin), and we can therefore assume that the app doesn't define an infinite loop (at least not in itself).
+        //  - There isn't a reliable way to check whether the redirect points to an external origin or the same origin; we hope/assume the user sets the URL without origin.
         //    ```js
         //    // For same-origin, the user usually/hopefully passes a URL without origin
         //    renderPage({ urlOriginal: '/some/pathname' })
         //    ```
         return;
     }
-    assert(urlLogical.startsWith('/'));
+    const urlOriginalNormalized = removeUrlOrigin(pageContextInit.urlOriginal).urlModified;
+    assert(urlOriginalNormalized.startsWith('/'));
     const graph = copy(globalObject.redirectGraph);
     graph[urlRedirectTarget] ?? (graph[urlRedirectTarget] = new Set());
-    graph[urlRedirectTarget].add(urlLogical);
+    graph[urlRedirectTarget].add(urlOriginalNormalized);
     validate(graph);
     globalObject.redirectGraph = graph;
 }

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

@@ -35,4 +35,6 @@ declare function createHttpResponseError(pageContext: null | {
     _pageConfigs: PageConfigRuntime[];
 }): HttpResponse;
 declare function createHttpResponsePageContextJson(pageContextSerialized: string): Promise<HttpResponse>;
-declare function createHttpResponseRedirect({ url, statusCode }: UrlRedirect, urlLogical: string): HttpResponse;
+declare function createHttpResponseRedirect({ url, statusCode }: UrlRedirect, pageContextInit: {
+    urlOriginal: string;
+}): HttpResponse;

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

@@ -82,10 +82,8 @@ async function createHttpResponsePageContextJson(pageContextSerialized) {
     const httpResponse = createHttpResponse(200, 'application/json', [], pageContextSerialized, [], null);
     return httpResponse;
 }
-function createHttpResponseRedirect({ url, statusCode }, 
-// The URL we assume the redirect to be logically based on
-urlLogical) {
-    assertNoInfiniteHttpRedirect(url, urlLogical);
+function createHttpResponseRedirect({ url, statusCode }, pageContextInit) {
+    assertNoInfiniteHttpRedirect(url, pageContextInit);
     assert(url);
     assert(statusCode);
     assert(300 <= statusCode && statusCode <= 399);

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

@@ -23,6 +23,10 @@ const errorsMisc = [
         errMsg: 'assets.json',
         link: 'https://vike.dev/getGlobalContext',
         mustMentionNodeModules: false
+    },
+    {
+        errMsg: 'ERR_UNKNOWN_FILE_EXTENSION',
+        link: 'https://vike.dev/broken-npm-package#err-unknown-file-extension'
     }
 ];
 const reactInvalidEelement = 'https://vike.dev/broken-npm-package#react-invalid-component';
@@ -73,7 +77,8 @@ const errorsCjsEsm = [
     { errMsg: 'exports is not defined' },
     { errMsg: 'module is not defined' },
     { errMsg: 'not defined in ES' },
-    { errMsg: "Unexpected token 'export'" }
+    { errMsg: "Unexpected token 'export'" },
+    { errMsg: 'Failed to resolve entry for package' }
 ];
 function logErrorHint(error) {
     /* Collect errors for ./logErrorHint.spec.ts

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

@@ -62,7 +62,7 @@ declare function prerenderPage(pageContext: PageContextInitEnhanced & PageFiles
             pageRoutes: import("../../../__internal/index.js").PageRoutes;
             onBeforeRouteHook: import("../../../shared/hooks/getHook.js").Hook | null;
             pages: import("../../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
-            config: import("../../../shared/page-configs/Config/PageContextConfig.js").ConfigResolved;
+            config: import("../../../types/index.js").ConfigResolved;
         } & ({
             isProduction: false;
             isPrerendering: false;
@@ -148,7 +148,7 @@ declare function prerenderPage(pageContext: PageContextInitEnhanced & PageFiles
             pageRoutes: import("../../../__internal/index.js").PageRoutes;
             onBeforeRouteHook: import("../../../shared/hooks/getHook.js").Hook | null;
             pages: import("../../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
-            config: import("../../../shared/page-configs/Config/PageContextConfig.js").ConfigResolved;
+            config: import("../../../types/index.js").ConfigResolved;
         } & ({
             isProduction: false;
             isPrerendering: false;
@@ -235,7 +235,7 @@ declare function prerender404Page(pageContextInit_: Record<string, unknown> | nu
             pageRoutes: import("../../../__internal/index.js").PageRoutes;
             onBeforeRouteHook: import("../../../shared/hooks/getHook.js").Hook | null;
             pages: import("../../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
-            config: import("../../../shared/page-configs/Config/PageContextConfig.js").ConfigResolved;
+            config: import("../../../types/index.js").ConfigResolved;
         } & ({
             isProduction: false;
             isPrerendering: false;
@@ -321,7 +321,7 @@ declare function prerender404Page(pageContextInit_: Record<string, unknown> | nu
             pageRoutes: import("../../../__internal/index.js").PageRoutes;
             onBeforeRouteHook: import("../../../shared/hooks/getHook.js").Hook | null;
             pages: import("../../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
-            config: import("../../../shared/page-configs/Config/PageContextConfig.js").ConfigResolved;
+            config: import("../../../types/index.js").ConfigResolved;
         } & ({
             isProduction: false;
             isPrerendering: false;
@@ -416,7 +416,7 @@ declare function getPageContextInitEnhanced(pageContextInit: {
         pageRoutes: import("../../../__internal/index.js").PageRoutes;
         onBeforeRouteHook: import("../../../shared/hooks/getHook.js").Hook | null;
         pages: import("../../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
-        config: import("../../../shared/page-configs/Config/PageContextConfig.js").ConfigResolved;
+        config: import("../../../types/index.js").ConfigResolved;
     } & ({
         isProduction: false;
         isPrerendering: false;

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

@@ -2,7 +2,7 @@ export { renderPage };
 export { renderPage_addAsyncHookwrapper };
 import { getPageContextInitEnhanced, renderPageAlreadyRouted } from './renderPage/renderPageAlreadyRouted.js';
 import { route } from '../../shared/route/index.js';
-import { assert, hasProp, objectAssign, isUrl, parseUrl, onSetupRuntime, assertWarning, getGlobalObject, checkType, assertUsage, normalizeUrlPathname, removeBaseServer, modifyUrlPathname, prependBase, removeUrlOrigin, setUrlOrigin, createUrlFromComponents, isUri, getUrlPretty } from './utils.js';
+import { assert, hasProp, objectAssign, isUrl, parseUrl, onSetupRuntime, assertWarning, getGlobalObject, checkType, assertUsage, normalizeUrlPathname, removeBaseServer, modifyUrlPathname, prependBase, removeUrlOrigin, setUrlOrigin, isUri, getUrlPretty } from './utils.js';
 import { assertNoInfiniteAbortLoop, getPageContextFromAllRewrites, isAbortError, logAbortErrorHandled } from '../../shared/route/abort.js';
 import { getGlobalContextInternal, initGlobalContext_renderPage } from './globalContext.js';
 import { handlePageContextRequestUrl } from './renderPage/handlePageContextRequestUrl.js';
@@ -341,7 +341,7 @@ async function normalizeUrl(pageContextInit, globalContext, httpRequestId) {
     if (!urlNormalized)
         return null;
     logRuntimeInfo?.(`URL normalized from ${pc.cyan(urlOriginal)} to ${pc.cyan(urlNormalized)} (https://vike.dev/url-normalization)`, httpRequestId, 'info');
-    const httpResponse = createHttpResponseRedirect({ url: urlNormalized, statusCode: 301 }, pageContextInit.urlOriginal);
+    const httpResponse = createHttpResponseRedirect({ url: urlNormalized, statusCode: 301 }, pageContextInit);
     const pageContextHttpResponse = createPageContext(pageContextInit);
     objectAssign(pageContextHttpResponse, { httpResponse });
     return pageContextHttpResponse;
@@ -383,7 +383,7 @@ async function getPermanentRedirect(pageContextInit, globalContext, httpRequestI
         assert(urlTarget !== pageContextInit.urlOriginal);
     }
     logRuntimeInfo?.(`Permanent redirection defined by config.redirects (https://vike.dev/redirects)`, httpRequestId, 'info');
-    const httpResponse = createHttpResponseRedirect({ url: urlTarget, statusCode: 301 }, urlWithoutBase);
+    const httpResponse = createHttpResponseRedirect({ url: urlTarget, statusCode: 301 }, pageContextInit);
     const pageContextHttpResponse = createPageContext(pageContextInit);
     objectAssign(pageContextHttpResponse, { httpResponse });
     return pageContextHttpResponse;
@@ -391,7 +391,9 @@ async function getPermanentRedirect(pageContextInit, globalContext, httpRequestI
 function normalize(url) {
     return url || '/';
 }
-async function handleAbortError(errAbort, pageContextsFromRewrite, pageContextInit, 
+async function handleAbortError(errAbort, pageContextsFromRewrite, 
+// The original `pageContextInit` object passed to `renderPage(pageContextInit)`
+pageContextInit, 
 // handleAbortError() creates a new pageContext object and we don't merge pageContextNominalPageInit to it: we only use some pageContextNominalPageInit information.
 pageContextNominalPageInit, httpRequestId, pageContextErrorPageInit, globalContext) {
     logAbortErrorHandled(errAbort, globalContext.isProduction, pageContextNominalPageInit);
@@ -429,13 +431,7 @@ pageContextNominalPageInit, httpRequestId, pageContextErrorPageInit, globalConte
     if (pageContextAbort._urlRedirect) {
         const pageContextReturn = createPageContext(pageContextInit);
         objectAssign(pageContextReturn, pageContextAbort);
-        const httpResponse = createHttpResponseRedirect(pageContextAbort._urlRedirect, (() => {
-            const { pathname, searchOriginal } = pageContextNominalPageInit.urlParsed;
-            const urlLogical = createUrlFromComponents(null, pathname, searchOriginal, 
-            // The server-side doesn't have access to the hash
-            null);
-            return urlLogical;
-        })());
+        const httpResponse = createHttpResponseRedirect(pageContextAbort._urlRedirect, pageContextInit);
         objectAssign(pageContextReturn, { httpResponse });
         return { pageContextReturn };
     }

package/dist/esm/node/runtime/utils.d.ts

@@ -11,7 +11,6 @@ export * from '../../utils/parseUrl.js';
 export * from '../../utils/parseUrl-extras.js';
 export * from '../../utils/slice.js';
 export * from '../../utils/sorter.js';
-export * from '../../utils/projectInfo.js';
 export * from '../../utils/isArray.js';
 export * from '../../utils/isObject.js';
 export * from '../../utils/objectAssign.js';

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

@@ -15,7 +15,6 @@ export * from '../../utils/parseUrl.js';
 export * from '../../utils/parseUrl-extras.js';
 export * from '../../utils/slice.js';
 export * from '../../utils/sorter.js';
-export * from '../../utils/projectInfo.js';
 export * from '../../utils/isArray.js';
 export * from '../../utils/isObject.js';
 export * from '../../utils/objectAssign.js';

package/dist/esm/node/runtime-dev/createDevMiddleware.js

@@ -9,16 +9,18 @@ import { setGlobalContext_isProduction } from '../runtime/globalContext.js';
  */
 async function createDevMiddleware(options = {}) {
     setGlobalContext_isProduction(false);
-    const viteConfigFromOptions = {
-        ...options.viteConfig,
-        server: {
-            ...options.viteConfig?.server,
-            middlewareMode: options.viteConfig?.server?.middlewareMode ?? true
+    const optionsMod = {
+        ...options,
+        viteConfig: {
+            ...options.viteConfig,
+            root: options.root ?? options.viteConfig?.root,
+            server: {
+                ...options.viteConfig?.server,
+                middlewareMode: options.viteConfig?.server?.middlewareMode ?? true
+            }
         }
     };
-    if (options.root)
-        viteConfigFromOptions.root = options.root;
-    const { viteConfigEnhanced } = await prepareViteApiCall(viteConfigFromOptions, 'dev');
+    const { viteConfigEnhanced } = await prepareViteApiCall(optionsMod, 'dev');
     const server = await createServer(viteConfigEnhanced);
     const devMiddleware = server.middlewares;
     return { devMiddleware, viteServer: server, viteConfig: server.config };

package/dist/esm/node/shared/assertV1Design.js

@@ -10,7 +10,8 @@ function assertV1Design(pageConfigs, pageFilesAll) {
             assert(pageConfigs.length > 0);
             const filesV1 = unique(pageConfigs
                 .map((p) => Object.values(p.configValueSources).map((sources) => sources
-                .map((c) => c.definedAtFilePath.filePathAbsoluteUserRootDir)
+                .map((c) => c.definedAtFilePath)
+                .map((definedAt) => (definedAt.definedBy ? null : definedAt.filePathAbsoluteUserRootDir))
                 .filter(isNotNullish)
                 .map((filePathToShowToUser) => indent + filePathToShowToUser)))
                 .flat(2));

package/dist/esm/node/shared/utils.d.ts

@@ -1,7 +1,6 @@
 export * from '../../utils/assert.js';
 export * from '../../utils/getFileExtension.js';
 export * from '../../utils/isPlainObject.js';
-export * from '../../utils/projectInfo.js';
 export * from '../../utils/checkType.js';
 export * from '../../utils/hasProp.js';
 export * from '../../utils/objectAssign.js';

package/dist/esm/node/shared/utils.js

@@ -3,7 +3,6 @@ assertIsNotBrowser();
 export * from '../../utils/assert.js';
 export * from '../../utils/getFileExtension.js';
 export * from '../../utils/isPlainObject.js';
-export * from '../../utils/projectInfo.js';
 export * from '../../utils/checkType.js';
 export * from '../../utils/hasProp.js';
 export * from '../../utils/objectAssign.js';

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

@@ -297,7 +297,9 @@ type ConfigBuiltIn = {
          */
         disableAutoRun?: boolean;
         /**
-         * Set prerender settings without enabling pre-rendering.
+         * Whether to enable pre-rendering.
+         *
+         * Setting `value: null` enables you to set prerender settings without activating pre-rendering. (Useful for Vike extensions.)
          *
          * https://vike.dev/prerender#value
          *
@@ -471,6 +473,22 @@ type ConfigBuiltIn = {
      * https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Cache-Control
      */
     cacheControl?: string;
+    /**
+     * Make development/preview server available over LAN and public addresses.
+     *
+     * Default: `false` (or `true` if running inside Docker/Podman).
+     *
+     * https://vike.dev/host
+     */
+    host?: boolean | string;
+    /**
+     * Change port of development/preview server.
+     *
+     * @default 3000
+     *
+     * https://vike.dev/port
+     */
+    port?: number;
     /** Where scripts are injected in the HTML.
      *
      * https://vike.dev/injectScriptsAt

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

@@ -17,12 +17,15 @@ export type { ConfigValueSources };
 export type { ConfigValuesComputed };
 export type { DefinedAtData };
 export type { DefinedAtFile };
+export type { DefinedAt };
+export type { DefinedBy };
 export type { DefinedAtFilePath };
 import type { ConfigValueSerialized } from './serialize/PageConfigSerialized.js';
 import type { LocationId } from '../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/filesystemRouting.js';
 import type { FilePath } from './FilePath.js';
 import type { ConfigDefinitions } from '../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/configDefinitionsBuiltIn.js';
 import type { PlusFile } from '../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/getPlusFilesAll.js';
+import type { Operation } from '../../node/api/types.js';
 type PageConfigCommon = {
     pageId: string;
 } & PageConfigRoute;
@@ -33,7 +36,7 @@ type PageConfigRoute = {
     isErrorPage?: undefined;
     routeFilesystem: {
         routeString: string;
-        definedBy: string;
+        definedAtLocation: string;
     };
 };
 /** Page config, runtime data structure */
@@ -89,7 +92,7 @@ type ConfigValueSources = Record<string, // configName
 ConfigValueSource[]>;
 type ConfigValueSource = {
     configEnv: ConfigEnvInternal;
-    definedAtFilePath: DefinedAtFilePath;
+    definedAtFilePath: DefinedAtFilePath | DefinedBy;
     plusFile: PlusFile | null;
     locationId: LocationId;
     /** Wether the config value is loaded at runtime, for example config.Page or config.onBeforeRender */
@@ -119,13 +122,13 @@ type ConfigValue = ConfigValueStandard | ConfigValueCumulative | ConfigValueComp
 type ConfigValueStandard = {
     type: 'standard';
     value: unknown;
-    definedAtData: DefinedAtFile;
+    definedAtData: DefinedAt;
 };
 /** Defined by multiple sources (thus multiple file paths). */
 type ConfigValueCumulative = {
     type: 'cumulative';
     value: unknown[];
-    definedAtData: DefinedAtFile[];
+    definedAtData: DefinedAt[];
 };
 /** Defined internally by Vike (currently, Vike doesn't support computed configs created by users). */
 type ConfigValueComputed = {
@@ -133,8 +136,16 @@ type ConfigValueComputed = {
     value: unknown;
     definedAtData: null;
 };
-type DefinedAtData = DefinedAtFile | DefinedAtFile[] | null;
+type DefinedAtData = DefinedAt | DefinedAt[] | null;
+type DefinedAt = DefinedAtFile | DefinedBy;
+type DefinedBy = {
+    definedBy: 'cli' | 'env';
+} | {
+    definedBy: 'api';
+    operation: Operation;
+};
 type DefinedAtFile = {
     filePathToShowToUser: string;
     fileExportPathToShowToUser: null | string[];
+    definedBy?: undefined;
 };

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

@@ -3,9 +3,9 @@ export { getConfigDefinedAtOptional };
 export { getDefinedAtString };
 export type { ConfigDefinedAt };
 export type { ConfigDefinedAtOptional };
-import type { DefinedAtData, DefinedAtFile } from './PageConfig.js';
+import type { DefinedAtData } from './PageConfig.js';
 type ConfigDefinedAtOptional = ConfigDefinedAt | `Config ${string} defined internally`;
 type ConfigDefinedAt = `Config ${string} defined at ${string}`;
-declare function getConfigDefinedAt<SentenceBegin extends 'Config' | 'config', ConfigName extends string>(sentenceBegin: SentenceBegin, configName: ConfigName, definedAtData: DefinedAtFile | DefinedAtFile[]): `${SentenceBegin} ${ConfigName} defined at ${string}`;
+declare function getConfigDefinedAt<SentenceBegin extends 'Config' | 'config', ConfigName extends string>(sentenceBegin: SentenceBegin, configName: ConfigName, definedAtData: NonNullable<DefinedAtData>): `${SentenceBegin} ${ConfigName} defined at ${string}`;
 declare function getConfigDefinedAtOptional<SentenceBegin extends 'Config' | 'config', ConfigName extends string>(sentenceBegin: SentenceBegin, configName: ConfigName, definedAtData: DefinedAtData): `${SentenceBegin} ${ConfigName} defined ${'internally' | `at ${string}`}`;
-declare function getDefinedAtString(definedAtData: DefinedAtFile | DefinedAtFile[], configName: string): string;
+declare function getDefinedAtString(definedAtData: NonNullable<DefinedAtData>, configName: string): string;

package/dist/esm/shared/page-configs/getConfigDefinedAt.js

@@ -1,7 +1,7 @@
 export { getConfigDefinedAt };
 export { getConfigDefinedAtOptional };
 export { getDefinedAtString };
-import { assert, isArray } from '../utils.js';
+import { assert, checkType, isArray } from '../utils.js';
 import pc from '@brillout/picocolors';
 import { getExportPath } from './getExportPath.js';
 function getConfigDefinedAt(sentenceBegin, configName, definedAtData) {
@@ -28,8 +28,10 @@ function getDefinedAtString(definedAtData, configName) {
     }
     assert(files.length >= 1);
     const definedAtString = files
-        .map((source) => {
-        const { filePathToShowToUser, fileExportPathToShowToUser } = source;
+        .map((definedAt) => {
+        if (definedAt.definedBy)
+            return getDefinedByString(definedAt, configName);
+        const { filePathToShowToUser, fileExportPathToShowToUser } = definedAt;
         let s = filePathToShowToUser;
         const exportPath = getExportPath(fileExportPathToShowToUser, configName);
         if (exportPath) {
@@ -40,3 +42,17 @@ function getDefinedAtString(definedAtData, configName) {
         .join(' / ');
     return definedAtString;
 }
+function getDefinedByString(definedAt, configName) {
+    if (definedAt.definedBy === 'api') {
+        return `API call ${pc.cyan(`${definedAt.operation}({${configName}})`)}`;
+    }
+    const { definedBy } = definedAt;
+    if (definedBy === 'cli') {
+        return `CLI option ${pc.cyan(`--${configName}`)}`;
+    }
+    if (definedBy === 'env') {
+        return `environment variable ${pc.cyan(`VIKE_OPTIONS="{${configName}}"`)}`;
+    }
+    checkType(definedBy);
+    assert(false);
+}

package/dist/esm/shared/page-configs/getConfigValueBuildTime.js

@@ -31,7 +31,7 @@ function getConfigValue(pageConfig, configName) {
         return {
             type: 'standard',
             value: configValueSource.value,
-            definedAtData: getDefinedAtFile(configValueSource)
+            definedAtData: getDefinedAt(configValueSource)
         };
     }
     else {
@@ -51,13 +51,16 @@ function mergeCumulative(configValueSources) {
         assert(configValueSource.configEnv.config === true);
         assert(configValueSource.valueIsLoaded);
         value.push(configValueSource.value);
-        definedAtData.push(getDefinedAtFile(configValueSource));
+        definedAtData.push(getDefinedAt(configValueSource));
     });
     return { value, definedAtData };
 }
-function getDefinedAtFile(configValueSource) {
+function getDefinedAt(configValueSource) {
+    const { definedAtFilePath } = configValueSource;
+    if (definedAtFilePath.definedBy)
+        return definedAtFilePath;
     return {
-        filePathToShowToUser: configValueSource.definedAtFilePath.filePathToShowToUser,
-        fileExportPathToShowToUser: configValueSource.definedAtFilePath.fileExportPathToShowToUser
+        filePathToShowToUser: definedAtFilePath.filePathToShowToUser,
+        fileExportPathToShowToUser: definedAtFilePath.fileExportPathToShowToUser
     };
 }

package/dist/esm/shared/page-configs/helpers.js

@@ -12,7 +12,7 @@ function getConfigValueFilePathToShowToUser(definedAtData) {
     // A unique file path only exists if the config value isn't cumulative nor computed:
     //  - cumulative config values have multiple file paths
     //  - computed values don't have any file path
-    if (!definedAtData || isArray(definedAtData))
+    if (!definedAtData || isArray(definedAtData) || definedAtData.definedBy)
         return null;
     const { filePathToShowToUser } = definedAtData;
     assert(filePathToShowToUser);

package/dist/esm/shared/page-configs/serialize/parsePageConfigs.d.ts

@@ -3,8 +3,8 @@ export { parseConfigValuesSerialized };
 import type { ConfigValues, PageConfigRuntime, PageConfigGlobalRuntime } from '../PageConfig.js';
 import type { PageConfigGlobalRuntimeSerialized, PageConfigRuntimeSerialized } from './PageConfigSerialized.js';
 import type { ConfigValueSerialized } from './PageConfigSerialized.js';
-declare function parseConfigValuesSerialized(configValuesSerialized: Record<string, ConfigValueSerialized>): ConfigValues;
 declare function parsePageConfigs(pageConfigsSerialized: PageConfigRuntimeSerialized[], pageConfigGlobalSerialized: PageConfigGlobalRuntimeSerialized): {
     pageConfigs: PageConfigRuntime[];
     pageConfigGlobal: PageConfigGlobalRuntime;
 };
+declare function parseConfigValuesSerialized(configValuesSerialized: Record<string, ConfigValueSerialized>): ConfigValues;

package/dist/esm/shared/page-configs/serialize/parsePageConfigs.js

@@ -4,10 +4,6 @@ import { assert, assertUsage, isCallable } from '../../utils.js';
 import { getConfigDefinedAt } from '../getConfigDefinedAt.js';
 import { parseTransform } from '@brillout/json-serializer/parse';
 import { assertPlusFileExport } from '../assertPlusFileExport.js';
-function parseConfigValuesSerialized(configValuesSerialized) {
-    const configValues = parseConfigValuesSerialized_tmp(configValuesSerialized);
-    return configValues;
-}
 function parsePageConfigs(pageConfigsSerialized, pageConfigGlobalSerialized) {
     // pageConfigs
     const pageConfigs = pageConfigsSerialized.map((pageConfigSerialized) => {
@@ -43,7 +39,7 @@ function assertRouteConfigValue(configValues) {
    }
    */
 }
-function parseConfigValuesSerialized_tmp(configValuesSerialized) {
+function parseConfigValuesSerialized(configValuesSerialized) {
     const configValues = {};
     Object.entries(configValuesSerialized).forEach(([configName, configValueSeriliazed]) => {
         let configValue;
@@ -100,6 +96,7 @@ function parseValueSerialized(valueSerialized, configName, getDefinedAtFile) {
     if (valueSerialized.type === 'plus-file') {
         const definedAtFile = getDefinedAtFile();
         const { exportValues } = valueSerialized;
+        assert(!definedAtFile.definedBy);
         assertPlusFileExport(exportValues, definedAtFile.filePathToShowToUser, configName);
         let value;
         let valueWasFound = false;

package/dist/esm/shared/page-configs/serialize/serializeConfigValues.d.ts

@@ -2,7 +2,7 @@ export { serializeConfigValues };
 export { getConfigValuesBase };
 export { isJsonValue };
 export type { FilesEnv };
-import type { ConfigEnvInternal, ConfigValueSource, DefinedAtFile, PageConfigBuildTime, PageConfigGlobalBuildTime } from '../PageConfig.js';
+import type { ConfigEnvInternal, ConfigValueSource, DefinedAt, PageConfigBuildTime, PageConfigGlobalBuildTime } from '../PageConfig.js';
 declare function serializeConfigValues(pageConfig: PageConfigBuildTime | PageConfigGlobalBuildTime, importStatements: string[], filesEnv: FilesEnv, isEnvMatch: (configEnv: ConfigEnvInternal) => boolean, tabspace: string, isEager: boolean | null): string[];
 declare function isJsonValue(value: unknown): boolean;
 declare function getConfigValuesBase(pageConfig: PageConfigBuildTime | PageConfigGlobalBuildTime, isEnvMatch: (configEnv: ConfigEnvInternal) => boolean, isEager: boolean | null): ConfigValuesBase;
@@ -17,14 +17,14 @@ type ConfigValuesBase = ({
 } | {
     configValueBase: {
         type: 'standard';
-        definedAtData: DefinedAtFile;
+        definedAtData: DefinedAt;
     };
     sourceRelevant: ConfigValueSource;
     configName: string;
 } | {
     configValueBase: {
         type: 'cumulative';
-        definedAtData: DefinedAtFile[];
+        definedAtData: DefinedAt[];
     };
     sourcesRelevant: ConfigValueSource[];
     configName: string;

package/dist/esm/shared/page-configs/serialize/serializeConfigValues.js

@@ -99,6 +99,7 @@ function serializeConfigValue(configValueBase, valueData, configName, lines, tab
 function getValueSerializedWithImport(configValueSource, importStatements, filesEnv, configName) {
     assert(!configValueSource.valueIsFilePath);
     const { valueIsDefinedByPlusValueFile, definedAtFilePath, configEnv } = configValueSource;
+    assert(!definedAtFilePath.definedBy);
     const { filePathAbsoluteVite, fileExportName } = definedAtFilePath;
     if (valueIsDefinedByPlusValueFile)
         assert(fileExportName === undefined);
@@ -226,9 +227,12 @@ function getConfigValuesBase(pageConfig, isEnvMatch, isEager) {
     return [...fromComputed, ...fromSources].filter((r) => r !== 'SKIP');
 }
 function getDefinedAtFileSource(source) {
+    const { definedAtFilePath } = source;
+    if (definedAtFilePath.definedBy)
+        return definedAtFilePath;
     const definedAtFile = {
-        filePathToShowToUser: source.definedAtFilePath.filePathToShowToUser,
-        fileExportPathToShowToUser: source.definedAtFilePath.fileExportPathToShowToUser
+        filePathToShowToUser: definedAtFilePath.filePathToShowToUser,
+        fileExportPathToShowToUser: definedAtFilePath.fileExportPathToShowToUser
     };
     return definedAtFile;
 }

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

@@ -60,11 +60,11 @@ function getPageRoutes(filesystemRoots, pageFilesAll, pageConfigs, allPageIds) {
             if (!pageRoute) {
                 const { routeFilesystem } = pageConfig;
                 assert(routeFilesystem);
-                const { routeString, definedBy } = routeFilesystem;
+                const { routeString, definedAtLocation } = routeFilesystem;
                 assert(routeFilesystem.routeString.startsWith('/'));
                 pageRoute = {
                     pageId,
-                    routeFilesystemDefinedBy: definedBy,
+                    routeFilesystemDefinedBy: definedAtLocation,
                     comesFromV1PageConfig,
                     routeString,
                     routeDefinedAtString: null,

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

@@ -8,9 +8,11 @@ export type { PageContextBuiltInServer } from '../shared/types.js';
 export type { PageContextBuiltInClientWithClientRouting } from '../shared/types.js';
 export type { PageContextBuiltInClientWithServerRouting } from '../shared/types.js';
 export type { Config, ConfigMeta as Meta, ImportString, DataAsync, DataSync, GuardAsync, GuardSync, OnBeforePrerenderStartAsync, OnBeforePrerenderStartSync, OnBeforeRenderAsync, OnBeforeRenderSync, OnBeforeRouteAsync, OnBeforeRouteSync, OnHydrationEndAsync, OnHydrationEndSync, OnPageTransitionEndAsync, OnPageTransitionEndSync, OnPageTransitionStartAsync, OnPageTransitionStartSync, OnPrerenderStartAsync, OnPrerenderStartSync, OnRenderClientAsync, OnRenderClientSync, OnRenderHtmlAsync, OnRenderHtmlSync, RouteAsync, RouteSync, KeepScrollPosition } from '../shared/page-configs/Config.js';
+export type { ConfigResolved } from '../shared/page-configs/Config/PageContextConfig.js';
 export type { ConfigEnv } from '../shared/page-configs/PageConfig.js';
 export type { ConfigDefinition, ConfigEffect } from '../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/configDefinitionsBuiltIn.js';
 export type { ConfigEntries } from '../shared/page-configs/getPageConfigUserFriendly.js';
+export type { VikeConfigPublic as VikeConfig } from '../node/plugin/plugins/commonConfig.js';
 export type { UrlPublic as Url } from '../utils/parseUrl.js';
 export type { InjectFilterEntry } from '../node/runtime/html/injectAssets/getHtmlTags.js';
 export { defineConfig } from './defineConfig.js';

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

@@ -1 +1 @@
-export declare const PROJECT_VERSION: "0.4.224";
+export declare const PROJECT_VERSION: "0.4.225";

package/dist/esm/utils/PROJECT_VERSION.js

@@ -1,2 +1,2 @@
 // Automatically updated by @brillout/release-me
-export const PROJECT_VERSION = '0.4.224';
+export const PROJECT_VERSION = '0.4.225';

package/dist/esm/utils/assert.js

@@ -12,7 +12,7 @@ import { assertSingleInstance_onAssertModuleLoad } from './assertSingleInstance.
 import { createErrorWithCleanStackTrace } from './createErrorWithCleanStackTrace.js';
 import { getGlobalObject } from './getGlobalObject.js';
 import { isObject } from './isObject.js';
-import { projectInfo } from './projectInfo.js';
+import { PROJECT_VERSION } from './PROJECT_VERSION.js';
 import pc from '@brillout/picocolors';
 const globalObject = getGlobalObject('utils/assert.ts', {
     alreadyLogged: new Set(),
@@ -29,7 +29,7 @@ const globalObject = getGlobalObject('utils/assert.ts', {
 });
 assertSingleInstance_onAssertModuleLoad();
 const projectTag = `[vike]`;
-const projectTagWithVersion = `[vike@${projectInfo.projectVersion}]`;
+const projectTagWithVersion = `[vike@${PROJECT_VERSION}]`;
 const bugTag = 'Bug';
 const numberOfStackTraceLinesToRemove = 2;
 function assert(condition, debugInfo) {