vike 0.4.230 → 0.4.231-commit-e23b4f5

package/dist/esm/shared/page-configs/{getUserFriendlyConfigs.js → resolveVikeConfigPublic.js}

@@ -1,51 +1,49 @@
-export { getUserFriendlyConfigsGlobal };
-export { getUserFriendlyConfigsPageEager };
-export { getUserFriendlyConfigsPageLazy };
+// TODO/now-same-api: use public API internally?
+// TODO/now-flat-pageContext: rename definedAt => definedBy
+export { resolveVikeConfigPublicGlobal };
+export { resolveVikeConfigPublicPageEager };
+export { resolveVikeConfigPublicPageLazy };
 import { assertDefaultExports, forbiddenDefaultExports } from '../getPageFiles/assert_exports_old_design.js';
 import { getConfigDefinedAtOptional, getDefinedAtString } from './getConfigDefinedAt.js';
 import { getConfigValueFilePathToShowToUser } from './helpers.js';
 import { assert, isObject, assertWarning, assertUsage, makeLast, isBrowser, isScriptFile, isTemplateFile, objectDefineProperty } from '../utils.js';
 import pc from '@brillout/picocolors';
-function getUserFriendlyConfigsPageEager(pageConfigGlobalValues, pageConfig, pageConfigValues) {
-    const pageConfigUserFriendly = getUserFriendlyConfigs_public({ pageConfigGlobalValues, pageConfigValues });
+function resolveVikeConfigPublicPageEager(pageConfigGlobalValues, pageConfig, pageConfigValues) {
+    const vikeConfigPublicPage_ = resolveVikeConfigPublic_base({ pageConfigGlobalValues, pageConfigValues });
+    const vikeConfigPublicPage = getPublicCopy(vikeConfigPublicPage_);
     let page;
     if (!pageConfig.isErrorPage) {
-        const route = pageConfigUserFriendly.config.route ?? pageConfig.routeFilesystem.routeString;
+        const route = vikeConfigPublicPage.config.route ?? pageConfig.routeFilesystem.routeString;
         page = {
-            ...pageConfigUserFriendly,
+            ...vikeConfigPublicPage,
             route
         };
     }
     else {
         page = {
-            ...pageConfigUserFriendly,
+            ...vikeConfigPublicPage,
             isErrorPage: true
         };
     }
     return [pageConfig.pageId, page];
 }
-function getUserFriendlyConfigs_public({ pageConfigGlobalValues, pageConfigValues }) {
-    const pageConfigUserFriendly = getUserFriendlyConfigs_base({ pageConfigGlobalValues, pageConfigValues });
-    return getPublicCopy(pageConfigUserFriendly);
-}
-function getPublicCopy(pageConfigUserFriendly) {
-    const p = pageConfigUserFriendly;
+function getPublicCopy(vikeConfigPublic) {
     return {
-        config: p.config,
-        _source: p.source,
-        _sources: p.sources,
-        _from: p.from
+        config: vikeConfigPublic.config,
+        _source: vikeConfigPublic.source,
+        _sources: vikeConfigPublic.sources,
+        _from: vikeConfigPublic.from
     };
 }
-function getUserFriendlyConfigs_base({ pageConfigGlobalValues, pageConfigValues }) {
+function resolveVikeConfigPublic_base({ pageConfigGlobalValues, pageConfigValues }) {
     const configValues = { ...pageConfigGlobalValues, ...pageConfigValues };
-    return getUserFriendlyConfigs_V1Design({ configValues });
+    return resolveVikeConfigPublic_V1Design({ configValues });
 }
-function getUserFriendlyConfigsGlobal({ pageConfigGlobalValues }) {
-    const pageConfigGlobalUserFriendly = getUserFriendlyConfigs_V1Design({ configValues: pageConfigGlobalValues });
-    return getPublicCopy(pageConfigGlobalUserFriendly);
+function resolveVikeConfigPublicGlobal({ pageConfigGlobalValues }) {
+    const vikeConfigPublicGlobal = resolveVikeConfigPublic_V1Design({ configValues: pageConfigGlobalValues });
+    return getPublicCopy(vikeConfigPublicGlobal);
 }
-function getUserFriendlyConfigsPageLazy(pageFiles, // V0.4 design
+function resolveVikeConfigPublicPageLazy(pageFiles, // V0.4 design
 pageConfig, // V1 design
 pageConfigGlobal) {
     const config = {};
@@ -72,7 +70,7 @@ pageConfigGlobal) {
     let sources;
     let from;
     if (pageConfig) {
-        const res = getUserFriendlyConfigs_base({
+        const res = resolveVikeConfigPublic_base({
             pageConfigGlobalValues: pageConfigGlobal.configValues,
             pageConfigValues: pageConfig.configValues
         });
@@ -112,7 +110,7 @@ pageConfigGlobal) {
         from,
         source,
         sources,
-        // TODO/eventually: deprecate/remove every prop below
+        // TODO/now-flat-pageContext: deprecate every prop below
         configEntries,
         exports,
         exportsAll
@@ -135,7 +133,7 @@ pageConfigGlobal) {
     return pageContextExports;
 }
 // V1 design
-function getUserFriendlyConfigs_V1Design(pageConfig) {
+function resolveVikeConfigPublic_V1Design(pageConfig) {
     const config = {};
     const configEntries = {};
     const exportsAll = {};
@@ -188,6 +186,7 @@ function getUserFriendlyConfigs_V1Design(pageConfig) {
         if (configValue.type === 'cumulative') {
             const src = {
                 type: 'configsCumulative',
+                definedAt: getDefinedAtString(configValue.definedAtData, configName),
                 values: configValue.value.map((value, i) => {
                     const definedAtFile = configValue.definedAtData[i];
                     assert(definedAtFile);
@@ -205,6 +204,7 @@ function getUserFriendlyConfigs_V1Design(pageConfig) {
         if (configValue.type === 'computed') {
             const src = {
                 type: 'configsComputed',
+                definedAt: 'Vike', // Vike currently doesn't support user-land computed configs => computed configs are always defined by Vike => there isn't any file path to show.
                 value: configValue.value
             };
             addSrc(src, configName);

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

@@ -2,12 +2,12 @@ export type { PageConfigRuntimeSerialized };
 export type { PageConfigGlobalRuntimeSerialized };
 export type { ConfigValueSerialized };
 export type { ValueSerialized };
-import type { ConfigValueStandard, ConfigValueComputed, ConfigValueCumulative, PageConfigCommon, PageConfigRuntime } from '../PageConfig.js';
+import type { ConfigValueStandard, ConfigValueComputed, ConfigValueCumulative, PageConfigCommon, PageConfigRuntime } from '../../../types/PageConfig.js';
 /** Page config data structure serialized in virtual files: parsing it results in PageConfigRuntime */
 type PageConfigRuntimeSerialized = PageConfigCommon & {
     /** Config values that are serializable and loaded eagerly such as config.passToClient */
     configValuesSerialized: Record<string, ConfigValueSerialized>;
-    loadConfigValuesAll: PageConfigRuntime['loadConfigValuesAll'];
+    loadConfigLazy: PageConfigRuntime['loadConfigLazy'];
 };
 type PageConfigGlobalRuntimeSerialized = {
     configValuesSerialized: Record<string, ConfigValueSerialized>;

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

@@ -1,6 +1,6 @@
 export { parsePageConfigs };
 export { parseConfigValuesSerialized };
-import type { ConfigValues, PageConfigRuntime, PageConfigGlobalRuntime } from '../PageConfig.js';
+import type { ConfigValues, PageConfigRuntime, PageConfigGlobalRuntime } from '../../../types/PageConfig.js';
 import type { PageConfigGlobalRuntimeSerialized, PageConfigRuntimeSerialized } from './PageConfigSerialized.js';
 import type { ConfigValueSerialized } from './PageConfigSerialized.js';
 declare function parsePageConfigs(pageConfigsSerialized: PageConfigRuntimeSerialized[], pageConfigGlobalSerialized: PageConfigGlobalRuntimeSerialized): {

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, DefinedAt, PageConfigBuildTime, PageConfigGlobalBuildTime } from '../PageConfig.js';
+import type { ConfigEnvInternal, ConfigValueSource, DefinedAt, PageConfigBuildTime, PageConfigGlobalBuildTime } from '../../../types/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;

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

@@ -2,12 +2,12 @@ export { serializeConfigValues };
 export { getConfigValuesBase };
 export { isJsonValue };
 import { assertIsNotProductionRuntime } from '../../../utils/assertSetup.js';
-import { assert, assertPosixPath, assertUsage, deepEqual, getPropAccessNotation, isImportPathRelative } from '../../../node/plugin/utils.js';
-import { parsePointerImportData } from '../../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/pointerImports.js';
+import { assert, assertPosixPath, assertUsage, deepEqual, getPropAccessNotation, isImportPathRelative } from '../../../node/vite/utils.js';
+import { parsePointerImportData } from '../../../node/vite/shared/resolveVikeConfigInternal/pointerImports.js';
 import { getConfigValueFilePathToShowToUser } from '../helpers.js';
 import { stringify } from '@brillout/json-serializer/stringify';
 import pc from '@brillout/picocolors';
-import { isOverriden } from '../../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig.js';
+import { isOverriden } from '../../../node/vite/shared/resolveVikeConfigInternal.js';
 const stringifyOptions = { forbidReactElements: true };
 const REPLACE_ME_BEFORE = '__VIKE__REPLACE_ME_BEFORE__';
 const REPLACE_ME_AFTER = '__VIKE__REPLACE_ME_AFTER__';

package/dist/esm/shared/preparePageContextForPublicUsage.js

@@ -27,7 +27,7 @@ function preparePageContextForPublicUsage(pageContext) {
     const globalContextPublic = prepareGlobalContextForPublicUsage(pageContext._globalContext);
     const pageContextPublic = getProxyForPublicUsage(pageContext, 'pageContext', 
     // We must skip it in the client-side because of the reactivity mechanism of UI frameworks like Solid.
-    // - TODO/now: double check whether that's true
+    // - TODO/now-proxy: double check whether that's true
     true, (prop) => {
         if (prop === 'globalContext') {
             return globalContextPublic;

package/dist/esm/shared/route/executeGuardHook.d.ts

@@ -1,9 +1,8 @@
 export { executeGuardHook };
-import type { PageFile } from '../getPageFiles.js';
-import type { PageConfigRuntime } from '../page-configs/PageConfig.js';
 import { type PageContextExecuteHook } from '../hooks/execHook.js';
+import type { GlobalContextInternal } from '../createGlobalContextShared.js';
 declare function executeGuardHook<PageContext extends {
     pageId: string;
-    _pageFilesAll: PageFile[];
-    _pageConfigs: PageConfigRuntime[];
+} & {
+    _globalContext: GlobalContextInternal;
 } & PageContextExecuteHook>(pageContext: PageContext, prepareForPublicUsage: (pageConfig: PageContext) => PageContext): Promise<void>;

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

@@ -5,11 +5,11 @@ import { execHookSingle } from '../hooks/execHook.js';
 const errIntro = 'The guard() hook defined by';
 async function executeGuardHook(pageContext, prepareForPublicUsage) {
     let hook;
-    if (pageContext._pageFilesAll.length > 0) {
+    if (pageContext._globalContext._pageFilesAll.length > 0) {
         // TODO/v1-release: remove
         // V0.4 design
-        assert(pageContext._pageConfigs.length === 0);
-        hook = findPageGuard(pageContext.pageId, pageContext._pageFilesAll);
+        assert(pageContext._globalContext._pageConfigs.length === 0);
+        hook = findPageGuard(pageContext.pageId, pageContext._globalContext._pageFilesAll);
     }
     else {
         // V1 design

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

@@ -7,9 +7,9 @@ import { execHookSync } from '../hooks/execHook.js';
 import { preparePageContextForPublicUsage } from '../preparePageContextForPublicUsage.js';
 async function executeOnBeforeRouteHook(pageContext) {
     const pageContextFromOnBeforeRouteHook = {};
-    if (!pageContext._onBeforeRouteHook)
+    if (!pageContext._globalContext._onBeforeRouteHook)
         return null;
-    const pageContextFromHook = await getPageContextFromHook(pageContext._onBeforeRouteHook, pageContext);
+    const pageContextFromHook = await getPageContextFromHook(pageContext._globalContext._onBeforeRouteHook, pageContext);
     if (pageContextFromHook) {
         objectAssign(pageContextFromOnBeforeRouteHook, pageContextFromHook);
         if (hasProp(pageContextFromOnBeforeRouteHook, 'pageId', 'string') ||
@@ -49,7 +49,7 @@ async function getPageContextFromHook(onBeforeRouteHook, pageContext) {
     if (hasProp(hookReturn.pageContext, 'pageId') && !hasProp(hookReturn.pageContext, 'pageId', 'null')) {
         const errPrefix2 = `${errPrefix} returned ${pc.cyan('{ pageContext: { pageId } }')} but ${pc.cyan('pageId')} should be`;
         assertUsage(hasProp(hookReturn.pageContext, 'pageId', 'string'), `${errPrefix2} a string or null`);
-        assertUsage(pageContext._allPageIds.includes(hookReturn.pageContext.pageId), `${errPrefix2} ${joinEnglish(pageContext._allPageIds.map((s) => pc.cyan(s)), 'or')}`);
+        assertUsage(pageContext._globalContext._allPageIds.includes(hookReturn.pageContext.pageId), `${errPrefix2} ${joinEnglish(pageContext._globalContext._allPageIds.map((s) => pc.cyan(s)), 'or')}`);
     }
     if (hasProp(hookReturn.pageContext, 'routeParams')) {
         assertRouteParams(hookReturn.pageContext, `${errPrefix} returned ${pc.cyan('{ pageContext: { routeParams } }')} but routeParams should`);

package/dist/esm/shared/route/index.d.ts

@@ -3,18 +3,11 @@ export type { PageContextForRoute };
 export type { PageContextFromRoute };
 export type { PageRoutes };
 export type { RouteMatches };
-import type { PageFile } from '../getPageFiles.js';
 import { type PageContextUrlInternal, type PageContextUrlSource } from '../getPageContextUrlComputed.js';
 import type { PageRoutes, RouteType } from './loadPageRoutes.js';
-import type { PageConfigRuntime, PageConfigGlobalRuntime } from '../page-configs/PageConfig.js';
-import type { Hook } from '../hooks/getHook.js';
+import type { GlobalContextInternal } from '../createGlobalContextShared.js';
 type PageContextForRoute = PageContextUrlInternal & {
-    _pageFilesAll: PageFile[];
-    _pageConfigs: PageConfigRuntime[];
-    _allPageIds: string[];
-    _pageConfigGlobal: PageConfigGlobalRuntime;
-    _pageRoutes: PageRoutes;
-    _onBeforeRouteHook: Hook | null;
+    _globalContext: GlobalContextInternal;
 } & PageContextUrlSource;
 type PageContextFromRoute = {
     pageId: string | null;

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

@@ -13,7 +13,7 @@ import { executeOnBeforeRouteHook } from './executeOnBeforeRouteHook.js';
 import { debug } from './debug.js';
 import pc from '@brillout/picocolors';
 async function route(pageContext, skipOnBeforeRouteHook) {
-    debug('Pages routes:', pageContext._pageRoutes);
+    debug('Pages routes:', pageContext._globalContext._pageRoutes);
     const pageContextFromRoute = {};
     // onBeforeRoute()
     if (!skipOnBeforeRouteHook) {
@@ -31,13 +31,13 @@ async function route(pageContext, skipOnBeforeRouteHook) {
         objectAssign(pageContext, pageContextFromOnBeforeRouteHook);
     }
     // Vike's routing
-    const allPageIds = pageContext._allPageIds;
+    const allPageIds = pageContext._globalContext._allPageIds;
     assertUsage(allPageIds.length > 0, 'No page found. You must create at least one page.');
-    assert(pageContext._pageFilesAll.length > 0 || pageContext._pageConfigs.length > 0);
+    assert(pageContext._globalContext._pageFilesAll.length > 0 || pageContext._globalContext._pageConfigs.length > 0);
     const { urlPathname } = pageContext;
     assert(urlPathname.startsWith('/'));
     const routeMatches = [];
-    await Promise.all(pageContext._pageRoutes.map(async (pageRoute) => {
+    await Promise.all(pageContext._globalContext._pageRoutes.map(async (pageRoute) => {
         const { pageId, routeType } = pageRoute;
         // Filesytem Routing
         if (pageRoute.routeType === 'FILESYSTEM') {

package/dist/esm/shared/route/loadPageRoutes.d.ts

@@ -2,7 +2,7 @@ export { loadPageRoutes };
 export type { PageRoutes };
 export type { RouteType };
 import type { PageFile } from '../getPageFiles.js';
-import type { PageConfigRuntime, PageConfigGlobalRuntime } from '../page-configs/PageConfig.js';
+import type { PageConfigRuntime, PageConfigGlobalRuntime } from '../../types/PageConfig.js';
 import { type Hook } from '../hooks/getHook.js';
 type PageRoute = {
     pageId: string;

package/dist/esm/{shared/page-configs → types}/Config/PageContextConfig.d.ts

@@ -1,6 +1,6 @@
 export type { PageContextConfig };
 export type { ConfigResolved };
-import type { VikePackages } from '../../VikeNamespace.js';
+import type { VikePackages } from '../VikeNamespace.js';
 import type { ConfigBuiltIn, ConfigBuiltInResolved, ImportString } from '../Config.js';
 import type { Combine, IsNotEmpty, XOR5 } from './helpers.js';
 type PageContextConfig = ConfigResolved & (ConfigVikePackagesNotEmptyXor extends true ? ConfigVikePackagesIntersection : ConfigVikePackagesCombined);

package/dist/esm/{shared/page-configs → types}/Config.d.ts

@@ -35,14 +35,14 @@ export type { RouteAsync };
 export type { RouteSync };
 export type { Route };
 export type { KeepScrollPosition };
-import type { PrefetchSetting, PrefetchStaticAssets } from '../../client/client-routing-runtime/prefetch/PrefetchSetting.js';
-import type { ConfigDefinition } from '../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/configDefinitionsBuiltIn.js';
-import type { DocumentHtml } from '../../node/runtime/html/renderHtml.js';
-import type { InjectFilterEntry } from '../../types/index.js';
-import type { VikeVitePluginOptions } from '../../node/plugin/index.js';
-import type { Vike, VikePackages } from '../VikeNamespace.js';
-import type { HooksTimeoutProvidedByUser } from '../hooks/getHook.js';
-import type { GlobalContext, PageContextClient, PageContextServer } from '../types.js';
+import type { PrefetchSetting, PrefetchStaticAssets } from '../client/runtime-client-routing/prefetch/PrefetchSetting.js';
+import type { ConfigDefinition } from '../node/vite/shared/resolveVikeConfigInternal/configDefinitionsBuiltIn.js';
+import type { DocumentHtml } from '../node/runtime/html/renderHtml.js';
+import type { InjectFilterEntry } from './index.js';
+import type { VikeVitePluginOptions } from '../node/vite/index.js';
+import type { Vike, VikePackages } from './VikeNamespace.js';
+import type { HooksTimeoutProvidedByUser } from '../shared/hooks/getHook.js';
+import type { GlobalContext, PageContextClient, PageContextServer } from './PageContext.js';
 import type { InlineConfig } from 'vite';
 type HookNameOld = HookName | HookNameOldDesign;
 type HookName = HookNamePage | HookNameGlobal;
@@ -538,7 +538,10 @@ type ConfigBuiltIn = {
      *
      * https://vike.dev/require
      */
-    require?: Record<string, string>;
+    require?: Record<string, string | {
+        version: string;
+        optional?: boolean;
+    }>;
     /** Whether the page scrolls to the top upon navigation.
      *
      * https://vike.dev/keepScrollPosition

package/dist/esm/{shared/page-configs → types}/PageConfig.d.ts

@@ -20,12 +20,12 @@ 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 { ConfigValueSerialized } from '../shared/page-configs/serialize/PageConfigSerialized.js';
+import type { LocationId } from '../node/vite/shared/resolveVikeConfigInternal/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';
+import type { ConfigDefinitionsInternal } from '../node/vite/shared/resolveVikeConfigInternal/configDefinitionsBuiltIn.js';
+import type { PlusFile } from '../node/vite/shared/resolveVikeConfigInternal/getPlusFilesAll.js';
+import type { Operation } from '../node/api/types.js';
 type PageConfigCommon = {
     pageId: string;
 } & PageConfigRoute;
@@ -43,7 +43,7 @@ type PageConfigRoute = {
 type PageConfigRuntime = PageConfigCommon & {
     configValues: ConfigValues;
     /** Load config values that are lazily loaded such as config.Page */
-    loadConfigValuesAll: LoadConfigValuesAll;
+    loadConfigLazy: LoadConfigLazy;
 };
 /** Global config that applies to all pages, runtime data structure */
 type PageConfigGlobalRuntime = {
@@ -51,7 +51,7 @@ type PageConfigGlobalRuntime = {
 };
 /** Page config, build-time data structure */
 type PageConfigBuildTime = PageConfigCommon & {
-    configDefinitions: ConfigDefinitions;
+    configDefinitions: ConfigDefinitionsInternal;
     plusFiles: PlusFile[];
     configValueSources: ConfigValueSources;
     configValuesComputed: ConfigValuesComputed;
@@ -59,15 +59,15 @@ type PageConfigBuildTime = PageConfigCommon & {
 /** Global config that applies to all pages, build-time data structure */
 type PageConfigGlobalBuildTime = {
     configValueSources: ConfigValueSources;
-    configDefinitions: ConfigDefinitions;
+    configDefinitions: ConfigDefinitionsInternal;
     configValuesComputed?: undefined;
 };
 /** Same as PageConfigRuntime but also contains all lazily loaded config values such as config.Page */
 type PageConfigRuntimeLoaded = PageConfigRuntime & {
-    /** Whether loadConfigValuesAll() was called */
+    /** Whether loadConfigLazy() was called */
     isAllLoaded: true;
 };
-type LoadConfigValuesAll = () => {
+type LoadConfigLazy = () => {
     moduleId: string;
     moduleExports: Promise<{
         configValuesSerialized: Record<string, ConfigValueSerialized>;
@@ -130,7 +130,7 @@ type ConfigValueCumulative = {
     value: unknown[];
     definedAtData: DefinedAt[];
 };
-/** Defined internally by Vike (currently, Vike doesn't support computed configs created by users). */
+/** Defined by Vike. */
 type ConfigValueComputed = {
     type: 'computed';
     value: unknown;

package/dist/esm/{shared/types.d.ts → types/PageContext.d.ts}

@@ -14,14 +14,14 @@ export type { PageContextInternalClient_ClientRouting };
 export type { PageContextBuiltInServer_deprecated as PageContextBuiltInServer };
 export type { PageContextBuiltInClientWithClientRouting_deprecated as PageContextBuiltInClientWithClientRouting };
 export type { PageContextBuiltInClientWithServerRouting_deprecated as PageContextBuiltInClientWithServerRouting };
-import type { PageContextUrlInternal, PageContextUrlClient, PageContextUrlServer } from './getPageContextUrlComputed.js';
-import type { ConfigEntries, ExportsAll, From, Source, Sources } from './page-configs/getUserFriendlyConfigs.js';
-import type { Config } from './page-configs/Config.js';
-import type { PageContextConfig } from './page-configs/Config/PageContextConfig.js';
-import type { AbortStatusCode } from './route/abort.js';
+import type { PageContextUrlInternal, PageContextUrlClient, PageContextUrlServer } from '../shared/getPageContextUrlComputed.js';
+import type { ConfigEntries, ExportsAll, From, Source, Sources } from '../shared/page-configs/resolveVikeConfigPublic.js';
+import type { Config } from './Config.js';
+import type { PageContextConfig } from './Config/PageContextConfig.js';
+import type { AbortStatusCode } from '../shared/route/abort.js';
 import type { GlobalContextServer } from '../node/runtime/globalContext.js';
-import type { GlobalContextClient } from '../client/client-routing-runtime/globalContext.js';
-import type { GlobalContextClientWithServerRouting } from '../client/server-routing-runtime/globalContext.js';
+import type { GlobalContextClient } from '../client/runtime-client-routing/globalContext.js';
+import type { GlobalContextClientWithServerRouting } from '../client/runtime-server-routing/globalContext.js';
 type PageContextServer<Data = unknown> = PageContextBuiltInServer<Data> & Vike.PageContext & Vike.PageContextServer;
 type PageContext<Data = unknown> = PageContextClient<Data> | PageContextServer<Data>;
 type PageContextClient<Data = unknown> = PageContextBuiltInClientWithClientRouting<Data> & Vike.PageContext & Vike.PageContextClient;

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

@@ -1,3 +1,3 @@
 export { defineConfig };
-import type { Config } from '../shared/page-configs/Config.js';
+import type { Config } from './Config.js';
 declare function defineConfig(config: Config): Config;

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

@@ -1,17 +1,17 @@
-export type { PageContext, PageContextServer, PageContextClient, GlobalContext, GlobalContextServer, GlobalContextClient, PageContextWithServerRouting, PageContextClientWithServerRouting, GlobalContextClientWithServerRouting } from '../shared/types.js';
-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/getUserFriendlyConfigs.js';
-export type { VikeConfigPublic as VikeConfig } from '../node/plugin/plugins/commonConfig.js';
+export type { PageContext, PageContextServer, PageContextClient, GlobalContext, GlobalContextServer, GlobalContextClient, PageContextWithServerRouting, PageContextClientWithServerRouting, GlobalContextClientWithServerRouting } from './PageContext.js';
+export type { PageContextBuiltInServer } from './PageContext.js';
+export type { PageContextBuiltInClientWithClientRouting } from './PageContext.js';
+export type { PageContextBuiltInClientWithServerRouting } from './PageContext.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 './Config.js';
+export type { ConfigResolved } from './Config/PageContextConfig.js';
+export type { ConfigEnv } from './PageConfig.js';
+export type { ConfigDefinition, ConfigEffect } from '../node/vite/shared/resolveVikeConfigInternal/configDefinitionsBuiltIn.js';
+export type { ConfigEntries } from '../shared/page-configs/resolveVikeConfigPublic.js';
+export type { VikeConfig } from '../node/vite/shared/resolveVikeConfigInternal.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';
-import type { ConfigEnv } from '../shared/page-configs/PageConfig.js';
+import type { ConfigEnv } from './PageConfig.js';
 /** @deprecated Replace:
  *   `import type { Env } from 'vike/types'`
  * With:
@@ -19,7 +19,7 @@ import type { ConfigEnv } from '../shared/page-configs/PageConfig.js';
  */
 type Env = ConfigEnv;
 export type { Env };
-import type { ConfigEffect } from '../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/configDefinitionsBuiltIn.js';
+import type { ConfigEffect } from '../node/vite/shared/resolveVikeConfigInternal/configDefinitionsBuiltIn.js';
 /** @deprecated Replace:
  *   `import type { Effect } from 'vike/types'`
  * With:
@@ -27,7 +27,7 @@ import type { ConfigEffect } from '../node/plugin/plugins/importUserCode/v1-desi
  */
 type Effect = ConfigEffect;
 export type { Effect };
-import { PageContextBuiltInClientWithServerRouting } from '../shared/types.js';
+import { PageContextBuiltInClientWithServerRouting } from './PageContext.js';
 /** @deprecated Replace:
  *   `import type { PageContextBuiltInClient } from 'vike/types'`
  * With:
@@ -37,7 +37,7 @@ import { PageContextBuiltInClientWithServerRouting } from '../shared/types.js';
  */
 type PageContextBuiltInClient<Page = any> = PageContextBuiltInClientWithServerRouting<Page>;
 export type { PageContextBuiltInClient };
-import { PageContextBuiltInServer } from '../shared/types.js';
+import { PageContextBuiltInServer } from './PageContext.js';
 /** @deprecated Replace:
  *   `import type { PageContextBuiltIn } from 'vike/types'`
  * With:

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

@@ -1 +1 @@
-export declare const PROJECT_VERSION: "0.4.230";
+export declare const PROJECT_VERSION: "0.4.231-commit-e23b4f5";

package/dist/esm/utils/PROJECT_VERSION.js

@@ -1,2 +1,2 @@
 // Automatically updated by @brillout/release-me
-export const PROJECT_VERSION = '0.4.230';
+export const PROJECT_VERSION = '0.4.231-commit-e23b4f5';

package/dist/esm/utils/assertSetup.js

@@ -83,7 +83,7 @@ function markSetup_vitePreviewServer() {
         debug('markSetup_vitePreviewServer()', new Error().stack);
     setup.vitePreviewServer = true;
 }
-// Called by ../node/plugin/index.ts
+// Called by ../node/vite/index.ts
 function markSetup_vikeVitePlugin() {
     if (debug.isActivated)
         debug('markSetup_vikeVitePlugin()', new Error().stack);

package/dist/esm/utils/assertSingleInstance.js

@@ -74,7 +74,7 @@ function assertSingleInstance_onClientEntryClientRouting(isProduction) {
         globalObject.checkSingleInstance = true;
     assertSingleInstance();
 }
-// Called by utils/assert.ts which is (most certainly) loaded by all entries. That way we don't have to call a callback for every entry. (There are a lot of entries: `client/router/`, `client/`, `node/runtime/`, `node/plugin/`, `node/cli`.)
+// Called by utils/assert.ts which is (most certainly) loaded by all entries. That way we don't have to call a callback for every entry. (There are a lot of entries: `client/router/`, `client/`, `node/runtime/`, `node/vite/`, `node/cli`.)
 function assertSingleInstance_onAssertModuleLoad() {
     const globalObject = getGlobalObjectSafe();
     globalObject.instances.push(PROJECT_VERSION);

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

@@ -1,7 +1,7 @@
 export { createDebugger };
 export { isDebugActivated };
 export type { Debug };
-declare const flags: readonly ["vike:crawl", "vike:error", "vike:esbuild-resolve", "vike:extractAssets", "vike:extractExportNames", "vike:glob", "vike:globalContext", "vike:log", "vike:optimizeDeps", "vike:outDir", "vike:pageFiles", "vike:pointer-imports", "vike:resolve", "vike:routing", "vike:setup", "vike:stream", "vike:virtual-files"];
+declare const flags: readonly ["vike:crawl", "vike:error", "vike:esbuild-resolve", "vike:pluginExtractAssets", "vike:pluginExtractExportNames", "vike:glob", "vike:globalContext", "vike:log", "vike:optimizeDeps", "vike:outDir", "vike:pageFiles", "vike:pointer-imports", "vike:resolve", "vike:routing", "vike:setup", "vike:stream", "vike:virtualFiles"];
 type Flag = (typeof flags)[number];
 type Debug = ReturnType<typeof createDebugger>;
 type Options = {

package/dist/esm/utils/debug.js

@@ -16,8 +16,8 @@ const flags = [
     'vike:crawl',
     'vike:error',
     'vike:esbuild-resolve',
-    'vike:extractAssets',
-    'vike:extractExportNames',
+    'vike:pluginExtractAssets',
+    'vike:pluginExtractExportNames',
     'vike:glob',
     'vike:globalContext',
     'vike:log',
@@ -29,7 +29,7 @@ const flags = [
     'vike:routing',
     'vike:setup',
     'vike:stream',
-    'vike:virtual-files'
+    'vike:virtualFiles'
 ];
 const flagsSkipWildcard = ['vike:log'];
 const flagRegex = /\bvike:[a-zA-Z-]+/g;

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

@@ -1,4 +1,6 @@
-export declare function genPromise<T = void>(): {
+export { genPromise };
+declare function genPromise<T = void>(): {
     promise: Promise<T>;
     resolve: (val: T) => void;
+    reject: (err: unknown) => void;
 };

package/dist/esm/utils/genPromise.js

@@ -1,5 +1,43 @@
-export function genPromise() {
+export { genPromise };
+// Simple implementation without timeout: https://github.com/vikejs/vike/blob/2e59b922e7e0f227d26018dc2b74877c9b0f581b/vike/utils/genPromise.ts
+import { assert, assertWarning } from './assert.js';
+const timeoutSeconds = 25;
+function genPromise() {
     let resolve;
-    const promise = new Promise((r) => (resolve = r));
-    return { promise, resolve };
+    let reject;
+    let finished = false;
+    const promise_internal = new Promise((resolve_, reject_) => {
+        resolve = (...args) => {
+            finished = true;
+            timeoutClear();
+            return resolve_(...args);
+        };
+        reject = (...args) => {
+            finished = true;
+            timeoutClear();
+            return reject_(...args);
+        };
+    });
+    const timeoutClear = () => timeouts.forEach((t) => clearTimeout(t));
+    const timeouts = [];
+    const promise = new Proxy(promise_internal, {
+        get(target, prop) {
+            if (prop === 'then' && !finished) {
+                const err = new Error(`Promise hasn't resolved after ${timeoutSeconds} seconds`);
+                timeouts.push(setTimeout(() => {
+                    assert(err.stack);
+                    assertWarning(false, removeStackErrorPrefix(err.stack), { onlyOnce: false });
+                }, timeoutSeconds * 1000));
+            }
+            const value = Reflect.get(target, prop);
+            return typeof value === 'function' ? value.bind(target) : value;
+        }
+    });
+    return { promise, resolve, reject };
+}
+function removeStackErrorPrefix(errStack) {
+    const errorPrefix = 'Error: ';
+    if (errStack.startsWith(errorPrefix))
+        errStack = errStack.slice(errorPrefix.length);
+    return errStack;
 }

package/dist/esm/utils/isDev.js

@@ -4,7 +4,9 @@ export { applyPreview };
 import { assertUsage } from './assert.js';
 function isDevCheck(configEnv) {
     const { isPreview, command } = configEnv;
-    // `assertVersion('Vite', version, '5.1.0')` isn't enough: https://github.com/vitejs/vite/pull/19355
+    // Note that:
+    // - `assertVersion('Vite', version, '5.1.0')` at node/vite/onLoad.ts isn't enough: https://github.com/vitejs/vite/pull/19355
+    // - We'll eventually be able to make this an assert() instead of assertUsage() once Vike requires a Vite version that supports this.meta.viteVersion
     assertUsage(typeof isPreview === 'boolean', 'You are using an old Vite version; make sure to use Vite 5.1.0 or above.');
     return command === 'serve' && !isPreview;
 }