vike 0.4.142-commit-acfc159 → 0.4.143-commit-f03b42d

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

@@ -628,7 +628,10 @@ function isStreamPipeWeb(thing) {
 const __streamPipeNode = '__streamPipeNode';
 /** @deprecated */
 function pipeNodeStream(pipe) {
-    assertWarning(false, 'pipeNodeStream() is outdated, use stampPipe() instead. See https://vike.dev/stream', { onlyOnce: true, showStackTrace: true });
+    assertWarning(false, 'pipeNodeStream() is outdated, use stampPipe() instead. See https://vike.dev/stream', {
+        onlyOnce: true,
+        showStackTrace: true
+    });
     return { [__streamPipeNode]: pipe };
 }
 function getStreamPipeNode(thing) {

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

@@ -1,5 +1,5 @@
 export { analyzePage };
 import type { PageFile } from '../../../shared/getPageFiles/getPageFileObject.js';
-import type { PageConfig } from '../../../shared/page-configs/PageConfig.js';
+import type { PageConfigRuntime } from '../../../shared/page-configs/PageConfig.js';
 import { type AnalysisResult } from '../../../shared/getPageFiles/analyzePageClientSide.js';
-declare function analyzePage(pageFilesAll: PageFile[], pageConfig: null | PageConfig, pageId: string): AnalysisResult;
+declare function analyzePage(pageFilesAll: PageFile[], pageConfig: null | PageConfigRuntime, pageId: string): AnalysisResult;

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

@@ -26,14 +26,14 @@ function analyzePage(pageFilesAll, pageConfig, pageId) {
         }
         /* Remove?
         Object.values(pageConfig.configElements).forEach((configElement) => {
-          if (configElement.importFilePath) {
+          if (configElement.importPath) {
             const { env } = configElement
             assert(env)
             const onlyAssets = env === 'server-only'
             const eagerlyImported = env === '_routing-eager'
             if (onlyAssets || eagerlyImported) {
               clientDependencies.push({
-                id: configElement.importFilePath,
+                id: configElement.importPath,
                 onlyAssets,
                 eagerlyImported
               })

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

@@ -4,7 +4,7 @@ export { createHttpResponseObjectRedirect };
 export type { HttpResponse };
 import type { GetPageAssets } from './getPageAssets.js';
 import type { HtmlRender } from '../html/renderHtml.js';
-import type { PageConfig } from '../../../shared/page-configs/PageConfig.js';
+import type { PageConfigRuntime } from '../../../shared/page-configs/PageConfig.js';
 import type { RenderHook } from './executeOnRenderHtmlHook.js';
 import type { RedirectStatusCode, AbortStatusCode, UrlRedirect } from '../../../shared/route/abort.js';
 import { HttpResponseBody } from './getHttpResponseBody.js';
@@ -21,7 +21,7 @@ declare function createHttpResponseObject(htmlRender: null | HtmlRender, renderH
     is404: null | boolean;
     errorWhileRendering: null | Error;
     __getPageAssets: GetPageAssets;
-    _pageConfigs: PageConfig[];
+    _pageConfigs: PageConfigRuntime[];
     abortStatusCode?: AbortStatusCode;
 }): Promise<HttpResponse | null>;
 declare function createHttpResponsePageContextJson(pageContextSerialized: string): Promise<HttpResponse>;

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

@@ -3,7 +3,7 @@ export type { PageContextDebug };
 import { RouteMatches } from '../../../shared/route/index.js';
 import type { ClientDependency } from '../../../shared/getPageFiles/analyzePageClientSide/ClientDependency.js';
 import type { PageFile } from '../../../shared/getPageFiles.js';
-import type { PageConfig } from '../../../shared/page-configs/PageConfig.js';
+import type { PageConfigRuntime } from '../../../shared/page-configs/PageConfig.js';
 type PageContextDebug = {
     _routeMatches: 'ROUTE_ERROR' | RouteMatches;
 };
@@ -12,7 +12,7 @@ declare function debugPageFiles({ pageContext, isHtmlOnly, isClientRouting, page
         urlOriginal: string;
         _pageId: string;
         _pageFilesAll: PageFile[];
-        _pageConfigs: PageConfig[];
+        _pageConfigs: PageConfigRuntime[];
     } & PageContextDebug;
     isHtmlOnly: boolean;
     isClientRouting: boolean;

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

@@ -3,7 +3,7 @@ export type { RenderHook };
 import { type HtmlRender } from '../html/renderHtml.js';
 import type { PageAsset } from './getPageAssets.js';
 import { type PageContextForUserConsumptionServerSide } from './preparePageContextForUserConsumptionServerSide.js';
-import type { PageConfig } from '../../../shared/page-configs/PageConfig.js';
+import type { PageConfigRuntime } from '../../../shared/page-configs/PageConfig.js';
 import type { PageContextSerialization } from '../html/serializePageContextClientSide.js';
 type GetPageAssets = () => Promise<PageAsset[]>;
 type RenderHook = {
@@ -13,7 +13,7 @@ type RenderHook = {
 type HookName = 'onRenderHtml' | 'render';
 declare function executeOnRenderHtmlHook(pageContext: PageContextForUserConsumptionServerSide & PageContextSerialization & {
     _pageId: string;
-    _pageConfigs: PageConfig[];
+    _pageConfigs: PageConfigRuntime[];
     __getPageAssets: GetPageAssets;
     _isHtmlOnly: boolean;
     _baseServer: string;

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

@@ -1,11 +1,11 @@
 export { handleErrorWithoutErrorPage };
 import type { PageContextAfterRender } from './renderPageAlreadyRouted.js';
-import type { PageConfig } from '../../../shared/page-configs/PageConfig.js';
+import type { PageConfigRuntime } from '../../../shared/page-configs/PageConfig.js';
 declare function handleErrorWithoutErrorPage<PageContext extends {
     isClientSideNavigation: boolean;
     errorWhileRendering: null | Error;
     is404: null | boolean;
     _pageId: null;
-    _pageConfigs: PageConfig[];
+    _pageConfigs: PageConfigRuntime[];
     urlOriginal: string;
 }>(pageContext: PageContext): Promise<PageContext & PageContextAfterRender>;

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

@@ -5,11 +5,11 @@ import { type PageFile } from '../../../shared/getPageFiles.js';
 import { PromiseType } from '../utils.js';
 import { PageContextGetPageAssets, type PageAsset } from './getPageAssets.js';
 import { type PageContextDebug } from './debugPageFiles.js';
-import type { PageConfig } from '../../../shared/page-configs/PageConfig.js';
+import type { PageConfigRuntime } from '../../../shared/page-configs/PageConfig.js';
 type PageContext_loadPageFilesServerSide = PageContextGetPageAssets & PageContextDebug & {
     urlOriginal: string;
     _pageFilesAll: PageFile[];
-    _pageConfigs: PageConfig[];
+    _pageConfigs: PageConfigRuntime[];
 };
 type PageFiles = PromiseType<ReturnType<typeof loadPageFilesServerSide>>;
 declare function loadPageFilesServerSide(pageContext: {

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

@@ -7,7 +7,7 @@ import { debugPageFiles } from './debugPageFiles.js';
 import { findPageConfig } from '../../../shared/page-configs/findPageConfig.js';
 import { analyzePage } from './analyzePage.js';
 import { getGlobalContext } from '../globalContext.js';
-import { loadPageCode } from '../../../shared/page-configs/loadPageCode.js';
+import { loadConfigValues } from '../../../shared/page-configs/loadConfigValues.js';
 async function loadPageFilesServerSide(pageContext) {
     const pageConfig = findPageConfig(pageContext._pageConfigs, pageContext._pageId); // Make pageConfig globally available as pageContext._pageConfig?
     const [{ config, configEntries, exports, exportsAll, pageExports, pageFilesLoaded, pageConfigLoaded }] = await Promise.all([
@@ -82,7 +82,7 @@ async function loadPageFilesServerSide(pageContext) {
 }
 async function loadPageFiles(pageFilesAll, pageConfig, pageId, isDev) {
     const pageFilesServerSide = getPageFilesServerSide(pageFilesAll, pageId);
-    const pageConfigLoaded = !pageConfig ? null : await loadPageCode(pageConfig, isDev);
+    const pageConfigLoaded = !pageConfig ? null : await loadConfigValues(pageConfig, isDev);
     await Promise.all(pageFilesServerSide.map((p) => p.loadFile?.()));
     const { config, configEntries, exports, exportsAll, pageExports } = getExports(pageFilesServerSide, pageConfigLoaded);
     return {

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

@@ -1,7 +1,7 @@
 export { preparePageContextForUserConsumptionServerSide };
 export type { PageContextForUserConsumptionServerSide };
 import { PageContextUrlComputedPropsInternal } from '../../../shared/addUrlComputedProps.js';
-import type { PageConfig } from '../../../shared/page-configs/PageConfig.js';
+import type { PageConfigRuntime } from '../../../shared/page-configs/PageConfig.js';
 import type { ConfigEntries, ExportsAll } from '../../../shared/getPageFiles/getExports.js';
 import { PageContextBuiltInServerInternal } from '../../../shared/types.js';
 type PageContextForUserConsumptionServerSide = PageContextBuiltInServerInternal & {
@@ -18,7 +18,7 @@ type PageContextForUserConsumptionServerSide = PageContextBuiltInServerInternal
     exports: Record<string, unknown>;
     exportsAll: ExportsAll;
     _pageId: string;
-    _pageConfigs: PageConfig[];
+    _pageConfigs: PageConfigRuntime[];
     is404: null | boolean;
     isClientSideNavigation: boolean;
     pageProps?: Record<string, unknown>;

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

@@ -10,7 +10,7 @@ import { type PageFile } from '../../../shared/getPageFiles.js';
 import { type PageContextUrlComputedPropsInternal } from '../../../shared/addUrlComputedProps.js';
 import { HttpResponse } from './createHttpResponseObject.js';
 import { PageContext_loadPageFilesServerSide, type PageFiles } from './loadPageFilesServerSide.js';
-import type { PageConfig, PageConfigGlobal } from '../../../shared/page-configs/PageConfig.js';
+import type { PageConfigRuntime, PageConfigGlobalRuntime } from '../../../shared/page-configs/PageConfig.js';
 import { type PageRoutes } from '../../../shared/route/loadPageRoutes.js';
 import type { OnBeforeRouteHook } from '../../../shared/route/executeOnBeforeRouteHook.js';
 type PageContextAfterRender = {
@@ -42,8 +42,8 @@ declare function prerenderPage(pageContext: PageContextInitEnhanced & PageFiles
         _baseAssets: string | null;
         _includeAssetsImportedByServer: boolean;
         _pageFilesAll: PageFile[];
-        _pageConfigs: PageConfig[];
-        _pageConfigGlobal: PageConfigGlobal;
+        _pageConfigs: PageConfigRuntime[];
+        _pageConfigGlobal: PageConfigGlobalRuntime;
         _allPageIds: string[];
         _pageRoutes: PageRoutes;
         _onBeforeRouteHook: OnBeforeRouteHook | null;
@@ -89,8 +89,8 @@ declare function prerenderPage(pageContext: PageContextInitEnhanced & PageFiles
         _baseAssets: string | null;
         _includeAssetsImportedByServer: boolean;
         _pageFilesAll: PageFile[];
-        _pageConfigs: PageConfig[];
-        _pageConfigGlobal: PageConfigGlobal;
+        _pageConfigs: PageConfigRuntime[];
+        _pageConfigGlobal: PageConfigGlobalRuntime;
         _allPageIds: string[];
         _pageRoutes: PageRoutes;
         _onBeforeRouteHook: OnBeforeRouteHook | null;
@@ -137,8 +137,8 @@ declare function prerender404Page(renderContext: RenderContext, pageContextInit_
         _baseAssets: string | null;
         _includeAssetsImportedByServer: boolean;
         _pageFilesAll: PageFile[];
-        _pageConfigs: PageConfig[];
-        _pageConfigGlobal: PageConfigGlobal;
+        _pageConfigs: PageConfigRuntime[];
+        _pageConfigGlobal: PageConfigGlobalRuntime;
         _allPageIds: string[];
         _pageRoutes: PageRoutes;
         _onBeforeRouteHook: OnBeforeRouteHook | null;
@@ -184,8 +184,8 @@ declare function prerender404Page(renderContext: RenderContext, pageContextInit_
         _baseAssets: string | null;
         _includeAssetsImportedByServer: boolean;
         _pageFilesAll: PageFile[];
-        _pageConfigs: PageConfig[];
-        _pageConfigGlobal: PageConfigGlobal;
+        _pageConfigs: PageConfigRuntime[];
+        _pageConfigGlobal: PageConfigGlobalRuntime;
         _allPageIds: string[];
         _pageRoutes: PageRoutes;
         _onBeforeRouteHook: OnBeforeRouteHook | null;
@@ -239,8 +239,8 @@ declare function getPageContextInitEnhanced(pageContextInit: {
     _baseAssets: string | null;
     _includeAssetsImportedByServer: boolean;
     _pageFilesAll: PageFile[];
-    _pageConfigs: PageConfig[];
-    _pageConfigGlobal: PageConfigGlobal;
+    _pageConfigs: PageConfigRuntime[];
+    _pageConfigGlobal: PageConfigGlobalRuntime;
     _allPageIds: string[];
     _pageRoutes: PageRoutes;
     _onBeforeRouteHook: OnBeforeRouteHook | null;
@@ -256,8 +256,8 @@ declare function getPageContextInitEnhanced(pageContextInit: {
 };
 type RenderContext = {
     pageFilesAll: PageFile[];
-    pageConfigs: PageConfig[];
-    pageConfigGlobal: PageConfigGlobal;
+    pageConfigs: PageConfigRuntime[];
+    pageConfigGlobal: PageConfigGlobalRuntime;
     allPageIds: string[];
     pageRoutes: PageRoutes;
     onBeforeRouteHook: OnBeforeRouteHook | null;

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

@@ -1,3 +1,3 @@
 export { getClientEntryFilePath };
-import type { PageConfig, PageConfigBuildTime } from '../../shared/page-configs/PageConfig.js';
-declare function getClientEntryFilePath(pageConfig: PageConfig | PageConfigBuildTime): null | string;
+import type { PageConfigRuntime, PageConfigBuildTime } from '../../shared/page-configs/PageConfig.js';
+declare function getClientEntryFilePath(pageConfig: PageConfigRuntime | PageConfigBuildTime): null | string;

package/dist/esm/node/shared/virtual-files/virtualFilePageConfigValuesAll.js

@@ -6,7 +6,7 @@ const idBase = 'virtual:vike:pageConfigValuesAll:';
 const idBaseClient = `${idBase}client:`;
 const idBaseServer = `${idBase}server:`;
 function getVirtualFileIdPageConfigValuesAll(pageId, isForClientSide) {
-    const id = `${(isForClientSide ? idBaseClient : idBaseServer)}${pageId}`;
+    const id = `${isForClientSide ? idBaseClient : idBaseServer}${pageId}`;
     return id;
 }
 function isVirtualFileIdPageConfigValuesAll(id) {

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

@@ -1,7 +1,7 @@
 export { addIs404ToPageProps };
-import type { PageConfig } from './page-configs/PageConfig.js';
+import type { PageConfigRuntime } from './page-configs/PageConfig.js';
 declare function addIs404ToPageProps(pageContext: Record<string, unknown> & PageContextAssertIs404): void;
 type PageContextAssertIs404 = {
     _pageId: string;
-    _pageConfigs: PageConfig[];
+    _pageConfigs: PageConfigRuntime[];
 };

package/dist/esm/shared/error-page.d.ts

@@ -1,8 +1,8 @@
 export { getErrorPageId };
 export { isErrorPageId };
 export { isErrorPage };
-import type { PageConfig } from './page-configs/PageConfig.js';
+import type { PageConfigRuntime } from './page-configs/PageConfig.js';
 import type { PageFile } from './getPageFiles.js';
-declare function getErrorPageId(pageFilesAll: PageFile[], pageConfigs: PageConfig[]): string | null;
+declare function getErrorPageId(pageFilesAll: PageFile[], pageConfigs: PageConfigRuntime[]): string | null;
 declare function isErrorPageId(pageId: string, _isV1Design: false): boolean;
-declare function isErrorPage(pageId: string, pageConfigs: PageConfig[]): boolean;
+declare function isErrorPage(pageId: string, pageConfigs: PageConfigRuntime[]): boolean;

package/dist/esm/shared/error-page.js

@@ -30,7 +30,7 @@ function isErrorPage(pageId, pageConfigs) {
     if (pageConfigs.length > 0) {
         const pageConfig = pageConfigs.find((p) => p.pageId === pageId);
         assert(pageConfig);
-        return pageConfig.isErrorPage;
+        return !!pageConfig.isErrorPage;
     }
     else {
         return isErrorPageId(pageId, false);

package/dist/esm/shared/getPageFiles/analyzeClientSide.d.ts

@@ -1,7 +1,7 @@
 export { analyzeClientSide };
-import type { PageConfig } from '../page-configs/PageConfig.js';
+import type { PageConfigRuntime } from '../page-configs/PageConfig.js';
 import type { PageFile } from './getPageFileObject.js';
-declare function analyzeClientSide(pageConfig: PageConfig | null, pageFilesAll: PageFile[], pageId: string): {
+declare function analyzeClientSide(pageConfig: PageConfigRuntime | null, pageFilesAll: PageFile[], pageId: string): {
     isClientSideRenderable: boolean;
     isClientRouting: boolean;
 };

package/dist/esm/shared/getPageFiles/assertPageConfigs.d.ts

@@ -1,5 +1,5 @@
-export { assertPageConfigs };
-export { assertPageConfigGlobal };
-import type { PageConfig, PageConfigGlobal } from '../page-configs/PageConfig.js';
-declare function assertPageConfigs(pageConfigs: unknown): asserts pageConfigs is PageConfig[];
-declare function assertPageConfigGlobal(pageConfigGlobal: unknown): asserts pageConfigGlobal is PageConfigGlobal;
+export { assertPageConfigsSerialized };
+export { assertPageConfigGlobalSerialized };
+import type { PageConfigGlobalRuntimeSerialized, PageConfigRuntimeSerialized } from '../page-configs/PageConfig.js';
+declare function assertPageConfigsSerialized(pageConfigsSerialized: unknown): asserts pageConfigsSerialized is PageConfigRuntimeSerialized[];
+declare function assertPageConfigGlobalSerialized(pageConfigGlobalSerialized: unknown): asserts pageConfigGlobalSerialized is PageConfigGlobalRuntimeSerialized;

package/dist/esm/shared/getPageFiles/assertPageConfigs.js

@@ -1,16 +1,16 @@
-export { assertPageConfigs };
-export { assertPageConfigGlobal };
+export { assertPageConfigsSerialized };
+export { assertPageConfigGlobalSerialized };
 import { assert, isObject, hasProp } from '../utils.js';
-function assertPageConfigs(pageConfigs) {
-    assert(Array.isArray(pageConfigs));
-    pageConfigs.forEach((pageConfig) => {
-        assert(isObject(pageConfig));
-        assert(hasProp(pageConfig, 'pageId', 'string'));
-        assert(hasProp(pageConfig, 'routeFilesystem'));
+function assertPageConfigsSerialized(pageConfigsSerialized) {
+    assert(Array.isArray(pageConfigsSerialized));
+    pageConfigsSerialized.forEach((pageConfigSerialized) => {
+        assert(isObject(pageConfigSerialized));
+        assert(hasProp(pageConfigSerialized, 'pageId', 'string'));
+        assert(hasProp(pageConfigSerialized, 'routeFilesystem'));
+        assert(hasProp(pageConfigSerialized, 'configValuesSerialized'));
+        assert(hasProp(pageConfigSerialized, 'configValuesImported'));
     });
 }
-function assertPageConfigGlobal(pageConfigGlobal) {
-    assert(pageConfigGlobal);
-    assert(hasProp(pageConfigGlobal, 'onBeforeRoute'));
-    assert(hasProp(pageConfigGlobal, 'onPrerenderStart'));
+function assertPageConfigGlobalSerialized(pageConfigGlobalSerialized) {
+    assert(hasProp(pageConfigGlobalSerialized, 'configValuesImported'));
 }

package/dist/esm/shared/getPageFiles/getExports.d.ts

@@ -4,7 +4,7 @@ export type { ExportsAll };
 export type { PageContextExports };
 export type { ConfigEntries };
 import type { FileType } from './fileTypes.js';
-import type { PageConfigLoaded } from './../page-configs/PageConfig.js';
+import type { PageConfigRuntimeLoaded } from './../page-configs/PageConfig.js';
 import type { PageFile } from './getPageFileObject.js';
 type ExportsAll = Record<string, {
     exportValue: unknown;
@@ -35,5 +35,5 @@ type PageContextExports = {
     /** @deprecated */
     pageExports: Record<string, unknown>;
 };
-declare function getExports(pageFiles: PageFile[], pageConfig: PageConfigLoaded | null): PageContextExports;
+declare function getExports(pageFiles: PageFile[], pageConfig: PageConfigRuntimeLoaded | null): PageContextExports;
 declare function getExportUnion(exportsAll: ExportsAll, propName: string): string[];

package/dist/esm/shared/getPageFiles/getExports.js

@@ -2,7 +2,7 @@ export { getExportUnion };
 export { getExports };
 import { isScriptFile, isTemplateFile } from '../../utils/isScriptFile.js';
 import { assert, hasProp, isObject, assertWarning, assertUsage, makeLast, isBrowser } from '../utils.js';
-import { assertDefaultExports, forbiddenDefaultExports } from './assertExports.js';
+import { assertDefaultExports, forbiddenDefaultExports } from './assert_exports_old_design.js';
 import { getConfigDefinedAtString } from '../page-configs/utils.js';
 import pc from '@brillout/picocolors';
 function getExports(pageFiles, pageConfig) {

package/dist/esm/shared/getPageFiles/parseGlobResults.d.ts

@@ -1,8 +1,8 @@
 export { parseGlobResults };
 import { type PageFile } from './getPageFileObject.js';
-import type { PageConfig, PageConfigGlobal } from '../page-configs/PageConfig.js';
+import type { PageConfigRuntime, PageConfigGlobalRuntime } from '../page-configs/PageConfig.js';
 declare function parseGlobResults(pageFilesExports: unknown): {
     pageFiles: PageFile[];
-    pageConfigs: PageConfig[];
-    pageConfigGlobal: PageConfigGlobal;
+    pageConfigs: PageConfigRuntime[];
+    pageConfigGlobal: PageConfigGlobalRuntime;
 };

package/dist/esm/shared/getPageFiles/parseGlobResults.js

@@ -1,9 +1,10 @@
 export { parseGlobResults };
 import { assert, hasProp, isCallable, isObject, cast, assertUsage } from '../utils.js';
-import { assertExportValues } from './assertExports.js';
+import { assertExportValues } from './assert_exports_old_design.js';
 import { getPageFileObject } from './getPageFileObject.js';
 import { fileTypes } from './fileTypes.js';
-import { assertPageConfigGlobal, assertPageConfigs } from './assertPageConfigs.js';
+import { assertPageConfigGlobalSerialized, assertPageConfigsSerialized } from './assertPageConfigs.js';
+import { parsePageConfigsSerialized } from './parsePageConfigsSerialized.js';
 function parseGlobResults(pageFilesExports) {
     assert(hasProp(pageFilesExports, 'isGeneratedFile'));
     assert(pageFilesExports.isGeneratedFile !== false, `vike was re-installed(/re-built). Restart your app.`);
@@ -15,12 +16,12 @@ function parseGlobResults(pageFilesExports) {
     assert(hasProp(pageFilesExports.pageFilesLazy, '.page'));
     assert(hasProp(pageFilesExports.pageFilesLazy, '.page.client') || hasProp(pageFilesExports.pageFilesLazy, '.page.server'));
     assert(hasProp(pageFilesExports, 'pageFilesList', 'string[]'));
-    assert(hasProp(pageFilesExports, 'pageConfigs'));
-    assert(hasProp(pageFilesExports, 'pageConfigGlobal'));
-    const { pageConfigs, pageConfigGlobal } = pageFilesExports;
-    assertPageConfigs(pageConfigs);
-    parsePageConfigs(pageConfigs);
-    assertPageConfigGlobal(pageConfigGlobal);
+    assert(hasProp(pageFilesExports, 'pageConfigsSerialized'));
+    assert(hasProp(pageFilesExports, 'pageConfigGlobalSerialized'));
+    const { pageConfigsSerialized, pageConfigGlobalSerialized } = pageFilesExports;
+    assertPageConfigsSerialized(pageConfigsSerialized);
+    assertPageConfigGlobalSerialized(pageConfigGlobalSerialized);
+    const { pageConfigs, pageConfigGlobal } = parsePageConfigsSerialized(pageConfigsSerialized, pageConfigGlobalSerialized);
     const pageFilesMap = {};
     parseGlobResult(pageFilesExports.pageFilesLazy).forEach(({ filePath, pageFile, globValue }) => {
         pageFile = pageFilesMap[filePath] = pageFilesMap[filePath] ?? pageFile;
@@ -87,38 +88,3 @@ function parseGlobResult(globObject) {
 function assertLoadModule(globValue) {
     assert(isCallable(globValue));
 }
-function parsePageConfigs(pageConfigs) {
-    // TODO: remove
-    /*
-    pageConfigs.forEach((pageConfig) => {
-      Object.entries(pageConfig.configElements).forEach(([configName, configElement]) => {
-        {
-          const { configValueSerialized } = configElement
-          if (configValueSerialized !== undefined) {
-            configElement.configValue = parse(configValueSerialized)
-          }
-        }
-        if (configName === 'route') {
-          assertRouteConfigValue(configElement)
-        }
-      })
-    })
-    */
-}
-// TODO: use again
-// function assertRouteConfigValue(configElement: ConfigElement) {
-//   assert(hasProp(configElement, 'configValue')) // route files are eagerly loaded
-//   const { configValue } = configElement
-//   const configValueType = typeof configValue
-//   assertUsage(
-//     configValueType === 'string' || isCallable(configValue),
-//     `${configElement.configDefinedAt} has an invalid type '${configValueType}': it should be a string or a function instead, see https://vike.dev/route`
-//   )
-//   /* We don't do that to avoid unnecessarily bloating the client-side bundle when using Server Routing
-//    *  - When using Server Routing, this file is loaded as well
-//    *  - When using Server Routing, client-side validation is superfluous as Route Strings only need to be validated on the server-side
-//   if (typeof configValue === 'string') {
-//     assertRouteString(configValue, `${configElement.configDefinedAt} defines an`)
-//   }
-//   */
-// }

package/dist/esm/shared/getPageFiles/parsePageConfigsSerialized.d.ts

@@ -0,0 +1,6 @@
+export { parsePageConfigsSerialized };
+import type { PageConfigRuntime, PageConfigGlobalRuntime, PageConfigGlobalRuntimeSerialized, PageConfigRuntimeSerialized } from '../page-configs/PageConfig.js';
+declare function parsePageConfigsSerialized(pageConfigsSerialized: PageConfigRuntimeSerialized[], pageConfigGlobalSerialized: PageConfigGlobalRuntimeSerialized): {
+    pageConfigs: PageConfigRuntime[];
+    pageConfigGlobal: PageConfigGlobalRuntime;
+};

package/dist/esm/shared/getPageFiles/parsePageConfigsSerialized.js

@@ -0,0 +1,59 @@
+export { parsePageConfigsSerialized };
+import { parse } from '@brillout/json-serializer/parse';
+import { parseConfigValuesImported } from '../page-configs/parseConfigValuesImported.js';
+import { assert, assertUsage, isCallable } from '../utils.js';
+function parsePageConfigsSerialized(pageConfigsSerialized, pageConfigGlobalSerialized) {
+    const pageConfigs = pageConfigsSerialized.map((pageConfigSerialized) => {
+        const configValues = {};
+        {
+            const { configValuesSerialized } = pageConfigSerialized;
+            Object.entries(configValuesSerialized).forEach(([configName, configValueSeriliazed]) => {
+                {
+                    const { valueSerialized, definedAtInfo } = configValueSeriliazed;
+                    assert(valueSerialized);
+                    assert(!configValues[configName]);
+                    configValues[configName] = {
+                        value: parse(valueSerialized),
+                        definedAtInfo
+                    };
+                }
+            });
+        }
+        {
+            const { configValuesImported } = pageConfigSerialized;
+            const configValuesAddendum = parseConfigValuesImported(configValuesImported);
+            Object.assign(configValues, configValuesAddendum);
+        }
+        const { pageId, isErrorPage, routeFilesystem, loadConfigValuesAll } = pageConfigSerialized;
+        assertRouteConfigValue(configValues);
+        return {
+            pageId,
+            isErrorPage,
+            routeFilesystem,
+            configValues,
+            loadConfigValuesAll
+        };
+    });
+    const pageConfigGlobal = { configValues: {} };
+    {
+        const configValuesAddendum = parseConfigValuesImported(pageConfigGlobalSerialized.configValuesImported);
+        Object.assign(pageConfigGlobal.configValues, configValuesAddendum);
+    }
+    return { pageConfigs, pageConfigGlobal };
+}
+function assertRouteConfigValue(configValues) {
+    if (!configValues.route)
+        return;
+    const { value, definedAtInfo } = configValues.route;
+    const configValueType = typeof value;
+    assert(definedAtInfo);
+    assertUsage(configValueType === 'string' || isCallable(value), `${definedAtInfo.filePath} has an invalid type '${configValueType}': it should be a string or a function instead, see https://vike.dev/route`);
+    /* We don't use assertRouteString() in order to avoid unnecessarily bloating the client-side bundle when using Server Routing:
+    * - When using Server Routing, this file is loaded => loading assertRouteString() would bloat the client bundle.
+    * - assertRouteString() is already called on the server-side
+    * - When using Server Routing, client-side validation is superfluous as Route Strings only need to be validated on the server-side
+   if (typeof configValue === 'string') {
+     assertRouteString(configValue, `${configElement.configDefinedAt} defines an`)
+   }
+   */
+}

package/dist/esm/shared/getPageFiles/setPageFiles.d.ts

@@ -2,12 +2,12 @@ export { setPageFiles };
 export { setPageFilesAsync };
 export { getPageFilesAll };
 import type { PageFile } from './getPageFileObject.js';
-import type { PageConfig, PageConfigGlobal } from '../page-configs/PageConfig.js';
+import type { PageConfigRuntime, PageConfigGlobalRuntime } from '../page-configs/PageConfig.js';
 declare function setPageFiles(pageFilesExports: unknown): void;
 declare function setPageFilesAsync(getPageFilesExports: () => Promise<unknown>): void;
 declare function getPageFilesAll(isClientSide: boolean, isProduction?: boolean): Promise<{
     pageFilesAll: PageFile[];
     allPageIds: string[];
-    pageConfigs: PageConfig[];
-    pageConfigGlobal: PageConfigGlobal;
+    pageConfigs: PageConfigRuntime[];
+    pageConfigGlobal: PageConfigGlobalRuntime;
 }>;